@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/selection/clipboard-text.js

@@ -1,183 +1,116 @@
-/**
- * Cross-block clipboard text collection.
- */
+/** Builds the plain text a cross-block selection puts on the clipboard. */
 import { makeBlockNode, metadataOf } from '../core/nodes';
 import { cloneMetadata } from '../tree-operations/clone';
 import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
-import { walkBetween, normalize, charOffsetOf, cellIndexOf } from './primitives';
-import { snapCrossBlockTableEndpoints } from './table-endpoint-snap';
-import { isStrictAncestorOf, pathHasPrefix, pathsEqual, sharedPrefixLength } from './path-math';
+import { charOffsetOf } from './primitives';
+import { gridClipboard } from './grid-selection';
+import { pathHasPrefix, pathsEqual } from './path-math';
 import { cellRowCol } from '../cursor/coordinate-spaces';
-import { displayLength, terminateLine } from '../core/lines';
+import { displayLength, documentLineEnding, terminateLine, trailingLineEnding } from '../core/lines';
 import { copyRectangleAsSubTable } from '../tree-operations/sub-table-copy';
 import { isReservedChromeChild } from '../schema/reserved-chrome';
 import { getBlockKindDescriptor, tryGetBlockKindDescriptor } from '../schema/block-kind-descriptor';
 // ── Public API ─────────────────────────────────────────────────────────────
-/**
- * Plain text spanning a cross-block selection: the start block's tail, every middle block's
- * leadingTrivia + raw, the end block's head. Descendants of an already-collected container
- * are skipped, since a container's raw already holds its children's text. Full-boundary leaf
- * endpoints promote to their deepest non-shared container ancestor so list markers and
- * blockquote prefixes survive; a start inside reserved chrome re-emits its container once.
- */
-export function collectCrossBlockText(doc, anchor, focus) {
-    const normalized = normalize({ anchor, focus });
-    const { start, end } = snapCrossBlockTableEndpoints(doc, normalized.start, normalized.end);
+/** The plain text of a covered range: whatever the coverage says is covered end to end is copied
+ *  whole, markers included, and a selection inside one table copies its rectangle. */
+export function collectCrossBlockText(doc, coverage) {
+    const { start, end } = coverage.range;
+    if (coverage.grid)
+        return gridClipboard(doc, coverage.grid)?.text ?? '';
     const startNode = nodeAt(doc, start.path);
     const endNode = nodeAt(doc, end.path);
     if (!startNode || !endNode)
         return '';
-    // On a table, offsets index half-open cell ranges (see `SelectionPoint`), not characters,
-    // so the three table branches route through emitTablePortion. Same-path intra-table offsets
-    // are context-established (unflagged) and read directly; cross-block ones use cellIndexOf.
-    if (pathsEqual(start.path, end.path) && isBlockNode(startNode) && startNode.kind === 'table') {
-        // Cell offsets are inclusive on both ends (hence the `+ 1`). A collapsed pair is a caret
-        // in a cell, not a rect, so copy nothing and let the cell's native copy handle it.
-        if (start.offset === end.offset)
-            return '';
-        return emitTablePortion(startNode, start.offset, end.offset + 1);
-    }
     const startRaw = isBlockNode(startNode) ? startNode.raw : '';
     const endRaw = isBlockNode(endNode) ? endNode.raw : '';
-    // One leaf taken whole (`SelectionState.wholeUnitPath`): the only same-path prose pair the
-    // state stores, and the head/tail split below would emit its bytes twice.
-    if (pathsEqual(start.path, end.path) && !start.cellCoordinate) {
+    // One block selected whole (`SelectionState.wholeUnitPath`) is the only character pair on one
+    // path, and the head/tail split below would emit its bytes twice.
+    if (pathsEqual(start.path, end.path)) {
         return startRaw.slice(start.offset, end.offset);
     }
+    const startRoot = coverage.coveredRootHolding(start.path);
+    const endRoot = coverage.coveredRootHolding(end.path);
+    if (startRoot && endRoot && pathsEqual(startRoot, endRoot))
+        return rawAt(doc, startRoot);
     let effectiveStartPath = start.path;
     let chromeStart = null;
     let startTail = '';
-    if (isBlockNode(startNode) && startNode.kind === 'table') {
-        const tableNode = startNode;
-        const colCount = metadataOf(tableNode, 'table').columnCount;
-        const allCellsCount = tableNode.children.length * colCount;
-        startTail = emitTablePortion(tableNode, cellIndexOf(start, 'collectCrossBlockText:startTable'), allCellsCount);
+    if (startRoot) {
+        effectiveStartPath = startRoot;
+        startTail = rawAt(doc, startRoot);
+    }
+    else if (coverage.startCells && isBlockNode(startNode)) {
+        startTail = emitTablePortion(startNode, coverage.startCells.from, coverage.startCells.to);
     }
     else {
         const startOffset = charOffsetOf(start, 'collectCrossBlockText:start');
-        if (startOffset === 0 && start.path.length > 1) {
-            const promoted = promoteToContainer(doc, start.path, end.path, 'start');
-            if (promoted) {
-                effectiveStartPath = promoted.path;
-                startTail = promoted.raw;
-            }
-            else {
-                startTail = startRaw.slice(startOffset);
-            }
-        }
-        else if (startOffset > 0 && start.path.length > 1) {
-            // A chrome start emits nothing here: its wrapper needs the body it encloses,
-            // which only the walk below knows.
-            chromeStart = startChromeContainer(doc, start, startRaw, startOffset);
-            if (!chromeStart) {
-                const marker = soleChildContainerPrefix(doc, start.path, startRaw);
-                startTail = (marker ?? '') + startRaw.slice(startOffset);
-            }
-        }
-        else {
-            startTail = startRaw.slice(startOffset);
+        // A start inside a container's title line emits nothing yet: the container's opener
+        // is rebuilt around the body, which the copy collects below.
+        chromeStart =
+            start.path.length > 1 ? startChromeContainer(doc, start, startRaw, startOffset) : null;
+        if (!chromeStart) {
+            const marker = start.path.length > 1 ? soleChildContainerPrefix(doc, start.path, startRaw) : null;
+            startTail = (marker ?? '') + startRaw.slice(startOffset);
         }
     }
+    // An end block covered to its last byte and held by no container keeps its line ending out, as
+    // a slice does; a container covered whole brings its own.
     let effectiveEndPath = end.path;
     let endHead;
-    if (isBlockNode(endNode) && endNode.kind === 'table') {
-        // Snapped end cell is the inclusive last cell of its row; emitTablePortion takes an
-        // exclusive end, so +1 makes the captured rows match the delete.
-        endHead = emitTablePortion(endNode, 0, cellIndexOf(end, 'collectCrossBlockText:endTable') + 1);
+    if (endRoot && endRoot.length < end.path.length) {
+        effectiveEndPath = endRoot;
+        endHead = rawAt(doc, endRoot);
+    }
+    else if (coverage.endCells && isBlockNode(endNode)) {
+        endHead = emitTablePortion(endNode, coverage.endCells.from, coverage.endCells.to);
     }
     else {
         const endOffset = charOffsetOf(end, 'collectCrossBlockText:end');
         const chromeBytes = endOffset > 0 ? endChromeContainerBytes(doc, end, endRaw, endOffset) : null;
-        if (chromeBytes !== null) {
-            endHead = chromeBytes;
-        }
-        else if (endOffset === displayLength(endRaw) && end.path.length > 1) {
-            const promoted = promoteToContainer(doc, end.path, start.path, 'end');
-            if (promoted) {
-                effectiveEndPath = promoted.path;
-                endHead = promoted.raw;
-            }
-            else {
-                endHead = endRaw.slice(0, endOffset);
-            }
-        }
-        else if (endOffset > 0 && endOffset < displayLength(endRaw) && end.path.length > 1) {
-            const marker = soleChildContainerPrefix(doc, end.path, endRaw);
-            endHead = (marker ?? '') + endRaw.slice(0, endOffset);
-        }
-        else {
-            endHead = endRaw.slice(0, endOffset);
-        }
+        const partial = endOffset > 0 && endOffset < displayLength(endRaw) && end.path.length > 1;
+        const marker = partial ? soleChildContainerPrefix(doc, end.path, endRaw) : null;
+        endHead = chromeBytes ?? (marker ?? '') + endRaw.slice(0, endOffset);
     }
     let middle = '';
     let chromeBody = '';
-    const collectedContainers = [];
-    for (const path of walkBetween(doc, effectiveStartPath, effectiveEndPath)) {
-        if (isStrictAncestorOf(path, effectiveStartPath))
+    for (const root of coverage.coveredWhole) {
+        if (pathHasPrefix(effectiveStartPath, root) || pathHasPrefix(effectiveEndPath, root))
             continue;
-        if (isStrictAncestorOf(path, effectiveEndPath))
-            continue;
-        if (isStrictAncestorOf(effectiveStartPath, path))
-            continue;
-        if (isStrictAncestorOf(effectiveEndPath, path))
-            continue;
-        if (collectedContainers.some((cp) => isStrictAncestorOf(cp, path)))
-            continue;
-        const node = nodeAt(doc, path);
+        const node = nodeAt(doc, root);
         if (!node || !isBlockNode(node))
             continue;
-        if (chromeStart && pathHasPrefix(path, chromeStart.path)) {
+        if (chromeStart && pathHasPrefix(root, chromeStart.path)) {
             chromeBody += node.leadingTrivia + node.raw;
         }
         else {
             middle += node.leadingTrivia + node.raw;
         }
-        if (node.children && node.children.length > 0) {
-            collectedContainers.push(path);
-        }
     }
     // Without endLead, blank lines between paragraphs drop and paste reparses as one paragraph.
-    let endLead = '';
-    if (!pathsEqual(effectiveStartPath, effectiveEndPath)) {
-        const endNode = nodeAt(doc, effectiveEndPath);
-        if (endNode && isBlockNode(endNode)) {
-            endLead = endNode.leadingTrivia;
-        }
-    }
+    const effectiveEnd = nodeAt(doc, effectiveEndPath);
+    const endLead = effectiveEnd && isBlockNode(effectiveEnd) ? effectiveEnd.leadingTrivia : '';
     if (chromeStart) {
         // The container's subtree is one contiguous doc-order run, so an end inside it
         // leaves `middle` empty and puts the end's own bytes inside the wrapper too.
         const exited = !pathHasPrefix(effectiveEndPath, chromeStart.path);
         const tail = endLead + endHead;
-        const wrapped = wrapChromeStartContainer(chromeStart, exited ? chromeBody : chromeBody + tail, exited);
+        const wrapped = wrapChromeStartContainer(chromeStart, exited ? chromeBody : chromeBody + tail, exited, documentLineEnding(doc));
         return exited ? wrapped + middle + tail : wrapped;
     }
     return startTail + middle + endLead + endHead;
 }
 // ── Internal ───────────────────────────────────────────────────────────────
-/**
- * Table portion for the half-open cell range `[startCellIdx, endCellIdxExclusive)`. Selection
- * is row-rectangular by GFM constraint, so emit `[startRow..endRow] × all columns`.
- */
+/** The table rows a kept table edge's cells touch, every column included, as a sub-table. */
 function emitTablePortion(table, startCellIdx, endCellIdxExclusive) {
     if (startCellIdx >= endCellIdxExclusive)
         return '';
     const colCount = metadataOf(table, 'table').columnCount;
-    const allCellsCount = table.children.length * colCount;
-    if (startCellIdx === 0 && endCellIdxExclusive === allCellsCount) {
-        return table.raw;
-    }
     const startRow = cellRowCol(startCellIdx, colCount).row;
     const endRow = cellRowCol(endCellIdxExclusive - 1, colCount).row;
     return copyRectangleAsSubTable(table, { rowIdx: startRow, colIdx: 0 }, { rowIdx: endRow, colIdx: colCount - 1 });
 }
-/**
- * The container marker prefix a partial-leaf slice must keep when the leaf is the sole child
- * of a strip container ("3. " so "3. thi" survives rather than "thi"). Without it CommonMark
- * §5.2 stops a following "N." line from interrupting the paragraph and the round-trip
- * collapses into one block. Eligibility is the descriptor's `strip` contract, not a kind list.
- * Sole-child is required: earlier siblings sit between the marker and the leaf's raw.
- */
+/** The list or quote marker a partial slice of a sole-child leaf keeps ("3. thi", not "thi"):
+ *  without it, a following "N." line joins the pasted paragraph and the text becomes one block. */
 function soleChildContainerPrefix(doc, leafPath, leafRaw) {
     const parent = nodeAt(doc, leafPath.slice(0, -1));
     if (!parent || !isBlockNode(parent) || !parent.children)
@@ -192,13 +125,8 @@ function soleChildContainerPrefix(doc, leafPath, leafRaw) {
         return null;
     return parent.raw.slice(0, parent.raw.length - leafRaw.length);
 }
-/**
- * The rebuild a chrome-wrapper synthesis may run for `container`, or null when re-emitting its
- * wrapper isn't faithful. Both chrome endpoint paths consult this and nothing else, so the
- * rule cannot hold on one endpoint and not the other. Only `'opaque'` qualifies: its syntax is
- * an opener plus a closer, so a truncated chrome IS an opener. `'strip'` has nothing to close
- * (`soleChildContainerPrefix` is its seam); `'grid'` declares no chrome and rides the table arm.
- */
+/** The kind's `rebuildRaw` when a copy endpoint in `container`'s title line can be re-emitted as
+ *  a truncated opener; only an `'opaque'` container's shortened title stays a valid opener. */
 function chromeWrapperRebuild(container, childIndex) {
     if (!isReservedChromeChild(container, childIndex))
         return null;
@@ -207,13 +135,8 @@ function chromeWrapperRebuild(container, childIndex) {
         return null;
     return descriptor.rebuildRaw ?? null;
 }
-/**
- * Bytes for a copy endpoint landing inside a container's reserved chrome. A generic raw.slice
- * emits wrapper-less bytes that reparse to a bare paragraph, losing the kind on paste, so
- * synthesize a chrome-only container (truncated chrome, empty body) and run the kind's own
- * rebuildRaw. Metadata is shallow-copied (primitive-valued by G1.6) because rebuildRaw is
- * plugin code fed a node that would otherwise alias the LIVE tree.
- */
+/** The bytes for a copy that ends inside a container's title line, rebuilt as a container with
+ *  an empty body, since a plain `raw.slice` would paste back as a bare paragraph. */
 function endChromeContainerBytes(doc, end, endRaw, endOffset) {
     const childIndex = end.path[end.path.length - 1];
     const parent = nodeAt(doc, end.path.slice(0, -1));
@@ -226,6 +149,7 @@ function endChromeContainerBytes(doc, end, endRaw, endOffset) {
         kind: parent.kind,
         leadingTrivia: '',
         raw: '',
+        // `rebuildRaw` is plugin code, so it gets a copy of the metadata, never the live tree's.
         metadata: parent.metadata ? cloneMetadata(parent.metadata) : undefined,
         innerPrefix: '',
         innerSuffix: '',
@@ -240,10 +164,8 @@ function endChromeContainerBytes(doc, end, endRaw, endOffset) {
     rebuildRaw(synthetic);
     return synthetic.raw;
 }
-/**
- * The container a copy STARTS inside the chrome of, when re-emitting its wrapper around the
- * collected body is faithful; null when it isn't. Eligibility is `chromeWrapperRebuild`'s.
- */
+/** The container whose title line the copy starts inside, when its opener can be re-emitted
+ *  around the collected body. */
 function startChromeContainer(doc, start, startRaw, startOffset) {
     const containerPath = start.path.slice(0, -1);
     const container = nodeAt(doc, containerPath);
@@ -259,20 +181,15 @@ function startChromeContainer(doc, start, startRaw, startOffset) {
         rebuildRaw
     };
 }
-/**
- * Re-emit the container around `body` with the truncated chrome back in the opener line. ONE
- * rebuildRaw call over the real body is what makes the closer trustworthy: a directive fence
- * widens when its body reproduces the terminator, so opener and closer derived in the same call
- * cannot disagree about width. `exited` means the walk left the subtree, i.e. the body ran to
- * the end, so the trailing inner trivia belongs to the copy; otherwise line-terminate instead.
- */
-function wrapChromeStartContainer(start, body, exited) {
+/** Re-emits the container around `body` in one `rebuildRaw` call, so a fence that widens for its
+ *  body keeps opener and closer in agreement. `exited`: the selection ran past the container. */
+function wrapChromeStartContainer(start, body, exited, ending) {
     const { node } = start;
     const innerSuffix = exited ? (node.innerSuffix ?? '') : '';
     const synthetic = makeBlockNode({
         kind: node.kind,
         leadingTrivia: '',
-        // The live raw, so the rebuild reads the authored closer line ending (G4.20).
+        // The live raw, so the rebuild copies the closer line's own line ending.
         raw: node.raw,
         metadata: node.metadata ? cloneMetadata(node.metadata) : undefined,
         innerPrefix: node.innerPrefix ?? '',
@@ -284,36 +201,16 @@ function wrapChromeStartContainer(start, body, exited) {
             makeBlockNode({
                 kind: 'paragraph',
                 leadingTrivia: '',
-                raw: innerSuffix === '' && body !== '' ? terminateLine(body, node.raw) : body
+                raw: innerSuffix === '' && body !== ''
+                    ? terminateLine(body, trailingLineEnding(node.raw, ending))
+                    : body
             })
         ]
     });
     start.rebuildRaw(synthetic);
     return synthetic.raw;
 }
-/**
- * Walk up from a leaf endpoint to the deepest container ancestor entirely inside the
- * selection. Start-side promotion is safe only while each child is first; end-side, last.
- */
-function promoteToContainer(doc, leafPath, otherPath, side) {
-    const lcaDepth = sharedPrefixLength(leafPath, otherPath);
-    let bestPath = null;
-    for (let depth = leafPath.length - 1; depth > lcaDepth; depth--) {
-        const parentPath = leafPath.slice(0, depth);
-        const parent = nodeAt(doc, parentPath);
-        if (!parent || !parent.children)
-            break;
-        const childIndex = leafPath[depth];
-        if (side === 'start' && childIndex !== 0)
-            break;
-        if (side === 'end' && childIndex !== parent.children.length - 1)
-            break;
-        bestPath = parentPath;
-    }
-    if (!bestPath || bestPath.length <= lcaDepth)
-        return null;
-    const node = nodeAt(doc, bestPath);
-    if (!node || !isBlockNode(node))
-        return null;
-    return { path: bestPath, raw: node.raw };
+function rawAt(doc, path) {
+    const node = nodeAt(doc, path);
+    return node && isBlockNode(node) ? node.raw : '';
 }

package/dist/selection/covered-block.d.ts

@@ -1,10 +1,8 @@
 /**
- * The block a range holds whole, for the gestures that insert over it. Such a range has no seam
- * inside it to merge at: the block leaves the tree entirely, so bytes that follow must land in
- * its SLOT rather than at a caret in whatever took the slot.
+ * The block a range covers whole, for the paste and typing paths that replace it, read off
+ * `rangeCoverage`. There is no join inside such a range to merge at: the block leaves the tree, so
+ * the new bytes go into its list position rather than at a caret in whatever block took it.
  */
-import type { DocumentView } from '../core/node-views';
-import type { SelectionPoint } from './primitives';
-/** The block both endpoints address and jointly span, or null. Cell coordinates index a grid
- *  rather than characters: the table's own coverage rule is `cross-block/paste.ts`'s. */
-export declare function blockCoveredWhole(doc: DocumentView, anchor: SelectionPoint | null, focus: SelectionPoint | null): number[] | null;
+import type { RangeCoverage } from './range-coverage';
+/** The one block both endpoints sit in and the range holds whole, a table included, or null. */
+export declare function blockCoveredWhole(coverage: RangeCoverage): number[] | null;

package/dist/selection/covered-block.js

@@ -1,24 +1,13 @@
 /**
- * The block a range holds whole, for the gestures that insert over it. Such a range has no seam
- * inside it to merge at: the block leaves the tree entirely, so bytes that follow must land in
- * its SLOT rather than at a caret in whatever took the slot.
+ * The block a range covers whole, for the paste and typing paths that replace it, read off
+ * `rangeCoverage`. There is no join inside such a range to merge at: the block leaves the tree, so
+ * the new bytes go into its list position rather than at a caret in whatever block took it.
  */
-import { displayLength } from '../core/lines';
-import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
 import { pathsEqual } from './path-math';
-/** The block both endpoints address and jointly span, or null. Cell coordinates index a grid
- *  rather than characters: the table's own coverage rule is `cross-block/paste.ts`'s. */
-export function blockCoveredWhole(doc, anchor, focus) {
-    if (!anchor || !focus)
+/** The one block both endpoints sit in and the range holds whole, a table included, or null. */
+export function blockCoveredWhole(coverage) {
+    const { start, end } = coverage.range;
+    if (!pathsEqual(start.path, end.path) || coverage.wholeRoots.length !== 1)
         return null;
-    if (!pathsEqual(anchor.path, focus.path))
-        return null;
-    if (anchor.cellCoordinate || focus.cellCoordinate)
-        return null;
-    const node = nodeAt(doc, anchor.path);
-    if (!node || !isBlockNode(node))
-        return null;
-    const low = Math.min(anchor.offset, focus.offset);
-    const high = Math.max(anchor.offset, focus.offset);
-    return low === 0 && high >= displayLength(node.raw) ? anchor.path.slice() : null;
+    return coverage.wholeRoots[0].slice();
 }

package/dist/selection/cross-block/clipboard.d.ts

@@ -1,6 +1,7 @@
 /**
- * Shared cross-block copy/cut prologue: each surface owns its intra-block logic but delegates
- * the cross-block branch here. The boolean return lets callers keep their own fall-through.
+ * The cross-block branch of copy and cut, shared by every editable block and the editor root:
+ * each block keeps its own single-block logic and delegates the cross-block case here, a cell
+ * rectangle included. The boolean return lets callers keep their own fall-through.
  */
 import type { DocumentGetter } from '../../editor-keys';
 import type { CrossBlockHandlers } from './dispatch';

package/dist/selection/cross-block/clipboard.js

@@ -1,20 +1,29 @@
 /**
- * Shared cross-block copy/cut prologue: each surface owns its intra-block logic but delegates
- * the cross-block branch here. The boolean return lets callers keep their own fall-through.
+ * The cross-block branch of copy and cut, shared by every editable block and the editor root:
+ * each block keeps its own single-block logic and delegates the cross-block case here, a cell
+ * rectangle included. The boolean return lets callers keep their own fall-through.
  */
 import { collectCrossBlockText } from '../clipboard-text';
+import { gridClipboard } from '../grid-selection';
+import { coverRange, rangeCoverage } from '../range-coverage';
 export function writeCrossBlockCopy(e, deps) {
     const { selection } = deps;
     if (!selection.isCrossBlock || !selection.anchor || !selection.focus)
         return false;
     e.preventDefault();
-    e.clipboardData?.setData('text/plain', collectCrossBlockText(deps.getDoc(), selection.anchor, selection.focus));
+    const doc = deps.getDoc();
+    const coverage = rangeCoverage(doc, coverRange(doc, selection.anchor, selection.focus));
+    const cells = coverage.grid && gridClipboard(doc, coverage.grid);
+    e.clipboardData?.setData('text/plain', cells ? cells.text : collectCrossBlockText(doc, coverage));
+    // A rectangle of cells also goes on as an HTML table, which spreadsheets read.
+    if (cells)
+        e.clipboardData?.setData('text/html', cells.html);
     return true;
 }
 export async function writeCrossBlockCut(e, deps) {
     if (!writeCrossBlockCopy(e, deps))
         return false;
     // Clipboard written synchronously above, so the cut survives an interrupted delete.
-    await deps.crossBlock.performCrossBlockDeleteFromEvent();
+    await deps.crossBlock.performCrossBlockCut();
     return true;
 }

package/dist/selection/cross-block/dispatch.d.ts

@@ -1,81 +1,85 @@
 /**
- * Cross-block event dispatch, wired by `components/blocks/editable-surface.ts` and by
- * `Editor.svelte` for editor-root routing. The factory returns handlers each caller runs at the
- * top of its own event handlers; single-block handling stays with the caller. This file is the
- * composer: keydown in keydown.ts, pointer in pointer.ts, paste / type-replace passthroughs.
+ * Cross-block event dispatch: handlers an editable block, or the editor root, runs at the top of
+ * its own event handlers, before its single-block handling.
  */
-import type { BlockEditActions, HistoryActions } from '../../action-contracts';
+import type { BlockEditActions } from '../../action-contracts';
 import type { BlockComponent } from '../../block-component';
-import type { BlockElLookup, DocumentGetter, LinkReferenceResolverRef, PluginEditorLookup, PresentationModeGetter } from '../../editor-keys';
+import type { BlockElLookup, DocumentGetter } from '../../editor-keys';
 import type { UserScrollport } from '../../cursor/scroll-ancestors';
+import type { ScrollOwner } from '../../cursor/scroll-owner';
 import type { SelectionState } from '../selection-state.svelte';
-import type { StickyColumnState } from '../../cursor/sticky-column';
-import type { EdgeAffinityState } from '../../cursor/edge-affinity';
+import type { SelectedWidgetHandle } from '../primitives';
+import type { CaretMemory } from '../../cursor/caret-memory';
+import type { CaretLanding } from '../caret-landing';
 import type { CommitController } from '../../action-contracts';
-import type { KeybindingOverrideMap } from '../../schema/keybinding-overrides';
-import type { CommandErrorSink, CrossBlockCommandRouter } from '../../schema/block-commands';
+import type { CommandDispatchContext } from '../../schema/block-commands';
 import type { EditorEvents } from '../../editor-events';
-import type { GrammarView } from '../../schema/block-openers';
+import type { Reading } from '../../schema/reading';
 import type { PluginActivation } from '../../schema/plugin-activation';
 import type { PasteCommitCoordinator } from '../../tree-operations/paste/paste-deps';
+import { type PaddingPress } from './pointer';
 export interface CrossBlockDispatchContext {
     getEl: () => HTMLElement | null;
     getMyPath: () => number[];
-    getIndex: () => number;
     selection: SelectionState;
     getDoc: DocumentGetter;
     getBlockElByPath: BlockElLookup;
+    /** Where a collapse, an extend's parked caret and a command's target block are put down. */
+    caretLanding: Pick<CaretLanding, 'restore' | 'park' | 'mount'>;
+    /** A mount for the delete, typing and paste over a range, which still place their own caret. */
     revealPath: (path: number[]) => Promise<BlockComponent | null>;
     getEditorRoot: () => HTMLElement | null;
     /** What autoscrolls a drag-select that reaches an edge: the root, the host's scroller, or the
      *  window. See `cursor/scroll-ancestors`. */
     getScrollHost: () => UserScrollport | null;
+    /** Brings the endpoint a keyboard extend reached to the nearest edge. */
+    scrollOwner: Pick<ScrollOwner, 'place'>;
     /** Aborted when the owning editor unmounts. See the document facet's `lifetime`. */
     getEditorLifetime: () => AbortSignal | null;
-    stickyColumn: StickyColumnState;
-    edgeAffinity: EdgeAffinityState;
+    caretMemory: CaretMemory;
     blockEdit: BlockEditActions;
     controller: CommitController;
-    history: HistoryActions;
-    pluginEditor: PluginEditorLookup | undefined;
-    /** The effective presentation mode; the destructive-branch reading gate keys off this. */
-    getPresentationMode: PresentationModeGetter | undefined;
-    /** The instance's link-reference resolver, forwarded to the delete's join seam. Required-
-     *  nullable like `pluginEditor`, so a new construction site can't silently skip the thread. */
-    linkRef: LinkReferenceResolverRef | undefined;
-    onCommandError: CommandErrorSink | undefined;
-    /** The arm a format chord takes over the live range; the seam routes there rather than
-     *  declining. Non-nullable: without it a rewrite chord is swallowed and nothing else. */
-    crossBlockCommands: CrossBlockCommandRouter;
-    getKeybindingOverrides: () => KeybindingOverrideMap;
+    /** How the editor reads its bytes: the delete's join cleanup and the paste reparse read it, and
+     *  the destructive branches refuse its reading mode. */
+    reading: Reading;
+    /** The editor's command dispatch, which runs a chord pressed over a range. */
+    commands: CommandDispatchContext;
     pasteCoordinator: PasteCommitCoordinator;
-    /** Block grammar forwarded to the join-paste reparse. Required-nullable like `pluginEditor`
-     *  so a new construction site can't silently skip the thread; `undefined` = global. */
-    grammar: GrammarView | undefined;
-    /** The plugins this instance activated, forwarded to the paste-transform pipeline.
-     *  Required-nullable like `grammar`; `undefined` means every installed plugin. */
-    activePlugins: PluginActivation | undefined;
-    /** The instance event surface, the paste arm's only channel for a gesture it consumed but
+    /** The plugins this instance activated, forwarded to the paste hooks. */
+    activePlugins: PluginActivation;
+    /** The editor's event emitter, the paste handler's only channel for a gesture it consumed but
      *  could not land. Non-nullable: skipping it drops a paste in silence. */
     events: EditorEvents;
-    getCursorOffset: () => number | null;
-    /** Svelte's tick() — awaited after mutations so the DOM settles. */
+    /** An image selected whole, which a shift-press grows its range from. */
+    selectedWidget: SelectedWidgetHandle;
+    /** Svelte's `tick()`, awaited after mutations so the DOM has updated. */
     afterReactivity: () => Promise<void>;
 }
+/** What the block handling a press knows about it that the shared pointer handler cannot read. */
+export interface PointerPressOptions {
+    /** The press landed on a non-editable inline widget (an emoji), which the browser starts no
+     *  drag from, so the block paints the range itself or the drag selects nothing. */
+    paintSameBlock?: boolean;
+    /** The raw offset the press anchors at, from a block that resolves its own press better than
+     *  the browser's hit test does. Absent, the point is hit-tested. */
+    anchorOffset?: number;
+    /** A block that runs its own drag from a press (a table's cell rectangle) installs it here, told
+     *  of a press in the padding the editor placed itself, where no native drag runs. */
+    ownDrag?: (padding: PaddingPress | null) => void;
+}
 export interface CrossBlockHandlers {
     /** Returns true if the event was fully handled (caller should return). */
     handleKeyDown(e: KeyboardEvent): Promise<boolean>;
-    handlePointerDown(e: PointerEvent): boolean;
-    /** `replacement` stands in for the clipboard's own text, for a caller that already turned the
-     *  payload into markdown and must not re-read the event past its awaits. A null event is a
-     *  programmatic insertion: no gesture to consume, so `replacement` carries the payload. */
+    handlePointerDown(e: PointerEvent, press?: PointerPressOptions): boolean;
+    /** `replacement` stands in for the clipboard text, for a caller that already converted the
+     *  payload and can't re-read the event after its awaits. A null event is a scripted insert. */
     handlePaste(e: ClipboardEvent | null, replacement?: string): Promise<boolean>;
     handleBeforeInput(e: InputEvent): Promise<boolean>;
-    /** Type-replace from a door that carries no InputEvent: the editor root, where a range over a
-     *  block with no character position leaves no editing surface for `beforeinput` to fire on. */
+    /** Type-replace from a caller with no `InputEvent`: the editor root, where a range over a block
+     *  with no character position leaves no editable element for `beforeinput` to fire on. */
     insertText(text: string): Promise<boolean>;
     handleCompositionStart(): boolean;
-    /** Cross-block range delete for Cut handlers, after they synchronously wrote the clipboard. */
-    performCrossBlockDeleteFromEvent(): Promise<void>;
+    /** The delete half of a cut, run once the handler wrote the clipboard synchronously. */
+    performCrossBlockCut(): Promise<void>;
 }
 export declare function createCrossBlockHandlers(ctx: CrossBlockDispatchContext): CrossBlockHandlers;