@voithos-labs/aragonite 0.10.1

package/dist/selection/block-hit-test.js

@@ -0,0 +1,59 @@
+/**
+ * Viewport point to the block under it, for pointer hit-testing: walks ancestors of the topmost
+ * element to the nearest `data-block-path` host. A kind with internal coordinate addressing
+ * carries the point→internals hooks its descriptor declares, so a caller resolves a
+ * cell-coordinate point without knowing the kind. What the hit does NOT carry is what a kind
+ * cannot answer: a block with no character surface reports none.
+ */
+import { WHOLE_BLOCK_INPUT_ATTR } from '../editor-actions/whole-block-focus-surface';
+import { tryGetBlockKindDescriptor } from '../schema/block-kind-descriptor';
+import { offsetFromViewportPoint } from '../cursor/point-offset';
+import { readBlockPath } from './path-lookup';
+export function blockAtPoint(editorRoot, clientX, clientY) {
+    let el = document.elementFromPoint(clientX, clientY);
+    while (el && el !== editorRoot) {
+        if (el instanceof HTMLElement && el.getAttribute('data-block-path')) {
+            const path = readBlockPath(el);
+            if (!path)
+                return null;
+            const wrapper = el;
+            const kind = wrapper.getAttribute('data-block-kind');
+            // tryGet tolerates junk DOM strings — unregistered kinds resolve undefined.
+            const descriptor = kind ? tryGetBlockKindDescriptor(kind) : undefined;
+            const dragHitTest = descriptor?.foreignDragHitTest;
+            const caretTarget = descriptor?.caretTargetAtPoint;
+            return {
+                path,
+                // A cell-addressed kind's first contenteditable is one of its CELLS, so declaring
+                // the drag hook withdraws the block-level surface rather than offering that. The
+                // whole-block editing host is chrome, not characters, so it is excluded too.
+                charSurface: dragHitTest
+                    ? null
+                    : wrapper.querySelector(`[contenteditable]:not([${WHOLE_BLOCK_INPUT_ATTR}])`),
+                foreignDragHitTest: dragHitTest && ((cx, cy) => dragHitTest(wrapper, cx, cy)),
+                caretTargetAtPoint: caretTarget && ((cx, cy) => caretTarget(wrapper, cx, cy))
+            };
+        }
+        el = el.parentElement;
+    }
+    return null;
+}
+/**
+ * The selection endpoint a pointer over `hit` addresses: a row-major cell index where the kind
+ * declares the drag hook, a char offset on a character surface, and otherwise the block as a
+ * whole — the selection funnel resolves which of its two ends this side of the range wants.
+ * Shared by both drag consumers, so neither can hit-test characters against a block with none.
+ */
+export function endpointAtPoint(hit, clientX, clientY) {
+    if (hit.foreignDragHitTest) {
+        const cellIdx = hit.foreignDragHitTest(clientX, clientY);
+        // The flag routes collapse/reveal to the deep cell, matching the keyboard path.
+        return cellIdx === null
+            ? null
+            : { path: hit.path, offset: cellIdx, cellCoordinate: true };
+    }
+    if (!hit.charSurface)
+        return { path: hit.path, wholeBlock: true };
+    const offset = offsetFromViewportPoint(hit.charSurface, clientX, clientY);
+    return offset === null ? null : { path: hit.path, offset };
+}

package/dist/selection/caret-doors.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The two caret doors a block component exposes. `parkCaret` is the primitive: it seats a caret
+ * and touches nothing else, which is what the cross-block dispatcher needs while an extend is
+ * still growing a range. `focus` is that primitive plus the claim-ending every other placement
+ * owes, since a caret left in a live cross-block range leaves a document the next keystroke
+ * type-replaces. The door a caller reaches for by default is the safe one.
+ */
+import type { GapCaretPosition } from './gap-caret';
+import type { SelectionState } from './selection-state.svelte';
+/**
+ * Mint a component's public `focus` from its park primitive. Batched because `clear()` notifies:
+ * an emission between the state write and the DOM landing reports a caret about to move.
+ */
+export declare function placeCaret(selection: SelectionState, parkCaret: (offset: number) => void): (offset: number) => void;
+/**
+ * The gap's own door: every arrival path writes gap state through here and nowhere else. The
+ * native clear is inside the batch because no native caret may outlive the landing — the gap
+ * owns the caret from here until something else claims it.
+ */
+export declare function placeGapCaret(selection: SelectionState, pos: GapCaretPosition): void;

package/dist/selection/caret-doors.js

@@ -0,0 +1,44 @@
+/**
+ * The two caret doors a block component exposes. `parkCaret` is the primitive: it seats a caret
+ * and touches nothing else, which is what the cross-block dispatcher needs while an extend is
+ * still growing a range. `focus` is that primitive plus the claim-ending every other placement
+ * owes, since a caret left in a live cross-block range leaves a document the next keystroke
+ * type-replaces. The door a caller reaches for by default is the safe one.
+ */
+import { clearNativeSelection } from './native-bridge';
+/**
+ * Mint a component's public `focus` from its park primitive. Batched because `clear()` notifies:
+ * an emission between the state write and the DOM landing reports a caret about to move.
+ */
+export function placeCaret(selection, parkCaret) {
+    return (offset) => selection.batch(() => {
+        endLiveCaretClaim(selection);
+        parkCaret(offset);
+    });
+}
+/**
+ * The gap's own door: every arrival path writes gap state through here and nowhere else. The
+ * native clear is inside the batch because no native caret may outlive the landing — the gap
+ * owns the caret from here until something else claims it.
+ */
+export function placeGapCaret(selection, pos) {
+    selection.batch(() => {
+        endLiveCaretClaim(selection);
+        selection.setGapCaret(pos);
+        clearNativeSelection();
+    });
+}
+/**
+ * Ends any editor-owned caret claim (cross-block range or gap) before a new caret lands. The
+ * range arm takes the gap with it, so the split is on which claim is live rather than on which
+ * field to zero. The native clear matters for a whole-block landing, which seats no DOM range
+ * of its own.
+ */
+function endLiveCaretClaim(selection) {
+    if (selection.isCrossBlock) {
+        selection.clear();
+        clearNativeSelection();
+        return;
+    }
+    selection.clearGapCaret();
+}

package/dist/selection/caret-restore.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Hold the document caret while editor-owned chrome borrows focus, and put it back on close.
+ * Focusing an overlay's input collapses the native selection, so the range has to live somewhere
+ * that outlives the borrow.
+ */
+export interface CaretRestore {
+    /** Snapshot the live caret. Null clears the slot, which makes `restore` fall back to the root. */
+    save(range: Range | null): void;
+    /** Snapshot the live caret from the window selection — the usual door. */
+    saveCurrent(): void;
+    /** Re-seat the saved caret and focus its host leaf. A container the DOM no longer holds falls
+     *  back to the editor root, so cross-block keyboard routing survives a rebuild. */
+    restore(): void;
+}
+export declare function createCaretRestore(getEditorEl: () => HTMLElement | null): CaretRestore;

package/dist/selection/caret-restore.js

@@ -0,0 +1,32 @@
+/**
+ * Hold the document caret while editor-owned chrome borrows focus, and put it back on close.
+ * Focusing an overlay's input collapses the native selection, so the range has to live somewhere
+ * that outlives the borrow.
+ */
+export function createCaretRestore(getEditorEl) {
+    let saved = null;
+    return {
+        save(range) {
+            saved = range;
+        },
+        saveCurrent() {
+            const selection = window.getSelection();
+            saved = selection && selection.rangeCount ? selection.getRangeAt(0).cloneRange() : null;
+        },
+        restore() {
+            const editorEl = getEditorEl();
+            if (saved && editorEl?.contains(saved.startContainer)) {
+                const node = saved.startContainer;
+                const host = node instanceof Element ? node : node.parentElement;
+                host?.closest('[contenteditable]')?.focus();
+                const selection = window.getSelection();
+                selection?.removeAllRanges();
+                selection?.addRange(saved);
+            }
+            else {
+                editorEl?.focus();
+            }
+            saved = null;
+        }
+    };
+}

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

@@ -0,0 +1,15 @@
+/**
+ * The char-space funnel, sibling of `table-endpoint-snap.ts`'s cell-space one: a cross-block
+ * endpoint's offset lands inside its own block's raw, and inside a kind with no character
+ * positions it lands on one of the two ends — a hit-test over such a block's rendered body walks
+ * chrome text and mints neither. Whole-unit inclusion is the rule: the side comes from document
+ * order against the other endpoint, never the anchor/focus role, which `normalize` reorders later.
+ */
+import type { DocumentView } from '../core/node-views';
+import { type SelectionEndpoint, type SelectionPoint } from './primitives';
+/**
+ * `endpoint` in its block's legal char space. Equal paths carry no document order — and no
+ * cross-block range — so they resolve to the block start. Tables are the cell funnel's subject
+ * and pass through untouched.
+ */
+export declare function normalizeCharEndpoint(doc: DocumentView, endpoint: SelectionEndpoint, otherPath: readonly number[]): SelectionPoint;

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

@@ -0,0 +1,39 @@
+/**
+ * The char-space funnel, sibling of `table-endpoint-snap.ts`'s cell-space one: a cross-block
+ * endpoint's offset lands inside its own block's raw, and inside a kind with no character
+ * positions it lands on one of the two ends — a hit-test over such a block's rendered body walks
+ * chrome text and mints neither. Whole-unit inclusion is the rule: the side comes from document
+ * order against the other endpoint, never the anchor/focus role, which `normalize` reorders later.
+ */
+import { displayLength, snapToScalarBoundary } from '../core/lines';
+import { isBlockNode, nodeAt } from '../tree-operations/node-ops';
+import { isWholeBlockUnit } from '../schema/whole-block-unit';
+import { comparePaths } from './path-math';
+import { isWholeBlockEndpoint } from './primitives';
+/**
+ * `endpoint` in its block's legal char space. Equal paths carry no document order — and no
+ * cross-block range — so they resolve to the block start. Tables are the cell funnel's subject
+ * and pass through untouched.
+ */
+export function normalizeCharEndpoint(doc, endpoint, otherPath) {
+    const node = nodeAt(doc, endpoint.path);
+    if (!node || !isBlockNode(node)) {
+        return isWholeBlockEndpoint(endpoint) ? { path: endpoint.path.slice(), offset: 0 } : endpoint;
+    }
+    const end = displayLength(node.raw);
+    const wholeUnit = {
+        path: endpoint.path.slice(),
+        offset: comparePaths(endpoint.path, otherPath) > 0 ? end : 0
+    };
+    if (isWholeBlockEndpoint(endpoint))
+        return wholeUnit;
+    if (node.kind === 'table')
+        return endpoint;
+    if (isWholeBlockUnit(node)) {
+        return endpoint.offset === 0 || endpoint.offset === end ? endpoint : wholeUnit;
+    }
+    // Range AND scalar: `setSelection` takes plain numbers, so this is the only gate between a
+    // caller's arithmetic and a delete that would halve an astral scalar.
+    const clamped = snapToScalarBoundary(node.raw, Math.min(Math.max(endpoint.offset, 0), end));
+    return clamped === endpoint.offset ? endpoint : { path: endpoint.path.slice(), offset: clamped };
+}

package/dist/selection/clipboard-text.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Cross-block clipboard text collection.
+ */
+import type { SelectionPoint } from './primitives';
+import type { DocumentView } from '../core/node-views';
+/**
+ * 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 declare function collectCrossBlockText(doc: DocumentView, anchor: SelectionPoint, focus: SelectionPoint): string;

package/dist/selection/clipboard-text.js

@@ -0,0 +1,314 @@
+/**
+ * Cross-block clipboard text collection.
+ */
+import { makeBlockNode, metadataOf } from '../core/nodes';
+import { cloneMetadata } from '../tree-operations/clone';
+import { isBlockNode, nodeAt } from '../tree-operations/node-ops';
+import { walkBetween, normalize, charOffsetOf, cellIndexOf } from './primitives';
+import { snapCrossBlockTableEndpoints } from './table-endpoint-snap';
+import { isStrictAncestorOf, pathHasPrefix, pathsEqual, sharedPrefixLength } from './path-math';
+import { cellRowCol } from '../cursor/coordinate-spaces';
+import { displayLength, terminateLine } 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);
+    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 : '';
+    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);
+    }
+    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);
+        }
+    }
+    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);
+    }
+    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);
+        }
+    }
+    let middle = '';
+    let chromeBody = '';
+    const collectedContainers = [];
+    for (const path of walkBetween(doc, effectiveStartPath, effectiveEndPath)) {
+        if (isStrictAncestorOf(path, effectiveStartPath))
+            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);
+        if (!node || !isBlockNode(node))
+            continue;
+        if (chromeStart && pathHasPrefix(path, 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;
+        }
+    }
+    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);
+        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`.
+ */
+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.
+ */
+function soleChildContainerPrefix(doc, leafPath, leafRaw) {
+    const parent = nodeAt(doc, leafPath.slice(0, -1));
+    if (!parent || !isBlockNode(parent) || !parent.children)
+        return null;
+    if (tryGetBlockKindDescriptor(parent.kind)?.containerContract !== 'strip')
+        return null;
+    if (parent.children.length !== 1)
+        return null;
+    if (leafPath[leafPath.length - 1] !== 0)
+        return null;
+    if (!parent.raw.endsWith(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.
+ */
+function chromeWrapperRebuild(container, childIndex) {
+    if (!isReservedChromeChild(container, childIndex))
+        return null;
+    const descriptor = getBlockKindDescriptor(container.kind);
+    if (descriptor.containerContract !== 'opaque')
+        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.
+ */
+function endChromeContainerBytes(doc, end, endRaw, endOffset) {
+    const childIndex = end.path[end.path.length - 1];
+    const parent = nodeAt(doc, end.path.slice(0, -1));
+    if (!parent || !isBlockNode(parent))
+        return null;
+    const rebuildRaw = chromeWrapperRebuild(parent, childIndex);
+    if (!rebuildRaw)
+        return null;
+    const synthetic = makeBlockNode({
+        kind: parent.kind,
+        leadingTrivia: '',
+        raw: '',
+        metadata: parent.metadata ? cloneMetadata(parent.metadata) : undefined,
+        innerPrefix: '',
+        innerSuffix: '',
+        children: [
+            makeBlockNode({
+                kind: parent.children[childIndex].kind,
+                leadingTrivia: '',
+                raw: endRaw.slice(0, 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.
+ */
+function startChromeContainer(doc, start, startRaw, startOffset) {
+    const containerPath = start.path.slice(0, -1);
+    const container = nodeAt(doc, containerPath);
+    if (!container || !isBlockNode(container))
+        return null;
+    const rebuildRaw = chromeWrapperRebuild(container, start.path[start.path.length - 1]);
+    if (!rebuildRaw)
+        return null;
+    return {
+        path: containerPath,
+        node: container,
+        chromeTail: startRaw.slice(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) {
+    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).
+        raw: node.raw,
+        metadata: node.metadata ? cloneMetadata(node.metadata) : undefined,
+        innerPrefix: node.innerPrefix ?? '',
+        innerSuffix,
+        children: [
+            makeBlockNode({ kind: node.children[0].kind, leadingTrivia: '', raw: start.chromeTail }),
+            // One stand-in for the whole collected body: a rebuild serializes its
+            // children's bytes, so the kind is immaterial and only the bytes travel.
+            makeBlockNode({
+                kind: 'paragraph',
+                leadingTrivia: '',
+                raw: innerSuffix === '' && body !== '' ? terminateLine(body, node.raw) : 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 };
+}

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

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+import type { DocumentGetter } from '../../editor-keys';
+import type { CrossBlockHandlers } from './dispatch';
+import type { SelectionState } from '../selection-state.svelte';
+export interface CrossBlockClipboardDeps {
+    selection: SelectionState;
+    getDoc: DocumentGetter;
+    crossBlock: CrossBlockHandlers;
+}
+export declare function writeCrossBlockCopy(e: ClipboardEvent, deps: CrossBlockClipboardDeps): boolean;
+export declare function writeCrossBlockCut(e: ClipboardEvent, deps: CrossBlockClipboardDeps): Promise<boolean>;

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

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+import { collectCrossBlockText } from '../clipboard-text';
+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));
+    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();
+    return true;
+}