@voithos-labs/aragonite 0.10.2 → 0.10.4

package/dist/selection/path-lookup.js

@@ -1,5 +1,5 @@
 /** Document-tree path navigation. Pure functions over a Document + path. */
-import { nodeAt } from '../tree-operations/node-ops';
+import { nodeAt } from '../tree-operations/node-primitives';
 /** Block immediately after `path` in doc order (children before siblings), else null. */
 export function nextPath(doc, path) {
     const node = nodeAt(doc, path);
@@ -125,8 +125,15 @@ export function findCellPathForElement(el) {
         return null;
     return [...tablePath, rowIdx, colIdx];
 }
-/** The path of the editing SURFACE `el` sits in — the enclosing cell where there is one, else
- *  the enclosing block. The pairing {@link findCellPathForElement} says every producer owes. */
+/** The pairing {@link findCellPathForElement} says every producer owes, in one place. */
+export function findSurfaceForElement(el) {
+    const cellPath = findCellPathForElement(el);
+    if (cellPath)
+        return { path: cellPath, inCell: true };
+    const blockPath = findBlockPathForElement(el);
+    return blockPath ? { path: blockPath, inCell: false } : null;
+}
+/** {@link findSurfaceForElement} for a caller that needs only the path. */
 export function findSurfacePathForElement(el) {
-    return findCellPathForElement(el) ?? findBlockPathForElement(el);
+    return findSurfaceForElement(el)?.path ?? null;
 }

package/dist/selection/pointer-gesture.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The door a widget declares over an element whose pointer drags belong to its own gesture (a
+ * diagram's pan, a canvas's brush): the editor's pointer arms decline a press inside it, so the
+ * gesture never doubles as a block range. A declaration, not a `stopPropagation`: pointer events
+ * are delegated at the app root, so a component's own handler runs after the editor's.
+ */
+/** Declared on the gesture surface itself; any descendant press counts. */
+export declare const POINTER_GESTURE_ATTR = "data-pointer-gesture";
+export declare function claimsPointerGesture(target: EventTarget | null): boolean;

package/dist/selection/pointer-gesture.js

@@ -0,0 +1,11 @@
+/**
+ * The door a widget declares over an element whose pointer drags belong to its own gesture (a
+ * diagram's pan, a canvas's brush): the editor's pointer arms decline a press inside it, so the
+ * gesture never doubles as a block range. A declaration, not a `stopPropagation`: pointer events
+ * are delegated at the app root, so a component's own handler runs after the editor's.
+ */
+/** Declared on the gesture surface itself; any descendant press counts. */
+export const POINTER_GESTURE_ATTR = 'data-pointer-gesture';
+export function claimsPointerGesture(target) {
+    return target instanceof Element && target.closest(`[${POINTER_GESTURE_ATTR}]`) !== null;
+}

package/dist/selection/primitives.d.ts

@@ -73,3 +73,10 @@ export type BlockSelectionClass = 'outside' | 'start' | 'middle' | 'end' | 'sing
  * tells the caller to delegate to the browser instead of painting.
  */
 export declare function classifyBlockForSelection(path: number[], selection: EditorSelection): BlockSelectionClass;
+/**
+ * Whether this block paints the range over its whole box: the range holds its entire subtree and
+ * no ancestor's box already covers it, or it is the whole unit a single-block range holds. Chrome
+ * a container derives from its markers (a GitHub alert's badge) has no child host to paint it, so
+ * the covering block takes the box in one piece and its children paint nothing.
+ */
+export declare function blockPaintsWholeBox(path: readonly number[], selection: EditorSelection, wholeUnitPath: readonly number[] | null): boolean;

package/dist/selection/primitives.js

@@ -3,7 +3,7 @@
  * classification, the delete-commit snapshot rule. No DOM, no state. Path-level predicates
  * live in `./path-math`.
  */
-import { comparePaths, isPathBetween, pathHasPrefix } from './path-math';
+import { comparePaths, isPathBetween, isStrictAncestorOf, pathHasPrefix, pathsEqual } from './path-math';
 import { asCellIndex, asRawOffset, docPathFrom } from '../cursor/coordinate-spaces';
 import { devWarn } from '../dev-warn';
 export function isWholeBlockEndpoint(endpoint) {
@@ -89,3 +89,21 @@ export function classifyBlockForSelection(path, selection) {
         return 'middle';
     return 'outside';
 }
+/**
+ * Whether this block paints the range over its whole box: the range holds its entire subtree and
+ * no ancestor's box already covers it, or it is the whole unit a single-block range holds. Chrome
+ * a container derives from its markers (a GitHub alert's badge) has no child host to paint it, so
+ * the covering block takes the box in one piece and its children paint nothing.
+ */
+export function blockPaintsWholeBox(path, selection, wholeUnitPath) {
+    if (wholeUnitPath)
+        return pathsEqual(path, wholeUnitPath);
+    const { start, end } = normalize(selection);
+    return (holdsSubtree(path, start.path, end.path) &&
+        !holdsSubtree(path.slice(0, -1), start.path, end.path));
+}
+/** The range holds this block's whole subtree: inside it in document order, and not an ancestor
+ *  of the end endpoint, whose own descendants the range cuts through. */
+function holdsSubtree(path, start, end) {
+    return isPathBetween(path, start, end) && !isStrictAncestorOf(path, end);
+}

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

@@ -10,8 +10,10 @@ import { charOffsetOf, walkBetween } from './primitives';
 import { comparePaths, isStrictAncestorOf, isPathSubtreeBetween, lowestCommonAncestor, pathHasPrefix, pathsEqual } from './path-math';
 import { cascadeCleanupEmptyAncestors } from '../tree-operations/cleanup';
 import { deleteAtPath, replaceAtPath } from '../tree-operations/path-mutate';
-import { blockNodeAt, cleanJoinedRaw, emptyParagraph, nodeAt, normalizeOwnRaw } from '../tree-operations/node-ops';
-import { ensureUnsharedPath, rebuildUnsharedAncestry, rebuildUnsharedChain } from '../tree-operations/unshare';
+import { blockNodeAt, emptyParagraph, nodeAt, normalizeOwnRaw } from '../tree-operations/node-primitives';
+import { cleanJoinedRaw } from '../tree-operations/node-ops';
+import { ensureUnsharedPath } from '../tree-operations/unshare';
+import { rebuildUnsharedAncestry, rebuildUnsharedChain } from '../tree-operations/chain-rebuild';
 // Wall primitives live with the chrome branch, which imports the atoms below back. The
 // resulting cycle is function-body-only (resolved at call time, never at module load), so it
 // is safe.

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

@@ -7,7 +7,8 @@
 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 { ensureUnsharedPath } from '../tree-operations/unshare';
+import { rebuildUnsharedChain } from '../tree-operations/chain-rebuild';
 import { reservedChromeKindOf, isReservedChromeChild } from '../schema/reserved-chrome';
 // ── Public API ──────────────────────────────────────────────────────────────
 /**

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

@@ -5,7 +5,8 @@
  */
 import { deleteSnapshot } from './primitives';
 import { metadataOf } from '../core/nodes';
-import { deleteNode, emptyParagraph } from '../tree-operations/node-ops';
+import { emptyParagraph } from '../tree-operations/node-primitives';
+import { deleteNode } from '../tree-operations/settle';
 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';

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

@@ -11,8 +11,9 @@ 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 { blockNodeAt, emptyParagraph } from '../tree-operations/node-primitives';
+import { ensureUnsharedNode, ensureUnsharedPath, ensureUnsharedSubtree, rebuildOwnedContainer } from '../tree-operations/unshare';
+import { rebuildUnsharedAncestry } from '../tree-operations/chain-rebuild';
 import { rebuildTableRowRaw } from '../schema/container-rebuilders';
 import { isCollapsedContainer } from '../schema/reserved-chrome';
 import { nearestChromeContainer, isChromeChild } from './range-delete-chrome';

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

@@ -31,3 +31,7 @@ export interface RangeDeleteResult {
  * post-unshare references. Caller pre-normalizes and keeps endpoints on focusable blocks.
  */
 export declare function rangeDelete(doc: Document, start: SelectionPoint, end: SelectionPoint, sharing: SharingState, grammar: GrammarView | undefined, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined): RangeDeleteResult;
+/** The container prefix the survivor renders under, so the join seam can read its candidate back
+ *  through it (live-mode.md § 4.5). An ambient marker rides the container's FIRST child only, the
+ *  way `BlockList` forwards it, and a list item is the one built-in container that paints one. */
+export declare function containerAmbientPrefix(doc: Document, path: readonly number[]): string;

package/dist/selection/range-delete.js

@@ -7,11 +7,30 @@ import { metadataOf } from '../core/nodes';
 import { walkBetween, charOffsetOf } from './primitives';
 import { comparePaths, lowestCommonAncestor, isPathSubtreeBetween } from './path-math';
 import { firstLeafAtOrAfter } from './path-lookup';
-import { blockNodeAt, cleanJoinedRaw, nodeAt, normalizeBodyWrite, normalizeOwnRaw, settleSeparatorOnBlank, writeOwnRaw } from '../tree-operations/node-ops';
+import { blockNodeAt, nodeAt, normalizeBodyWrite, normalizeOwnRaw, writeOwnRaw } from '../tree-operations/node-primitives';
+import { settleSeparatorOnBlank } from '../tree-operations/settle';
+import { isBlankParagraph } from '../core/parser';
+import { displayLength } from '../core/lines';
+import { deleteAtPath } from '../tree-operations/path-mutate';
+import { cleanJoinedRaw } from '../tree-operations/node-ops';
 import { deleteSubtreesIdentityGated, installTruncatedEndpoint, reparseTruncatedEndpoint } from './range-delete-ceremony';
-import { ensureUnsharedNode, ensureUnsharedPath, rebuildUnsharedAncestry, rebuildUnsharedChain } from '../tree-operations/unshare';
+import { ensureUnsharedNode, ensureUnsharedPath } from '../tree-operations/unshare';
+import { rebuildUnsharedAncestry, rebuildUnsharedChain } from '../tree-operations/chain-rebuild';
 import { involvesTable, tableAwareRangeDelete } from './range-delete-table';
 import { involvesReservedChrome, chromeAwareRangeDelete } from './range-delete-chrome';
+/** Whoever takes the slot gets the caret, at its start; the block above when nothing does. */
+function deleteWholeUnit(doc, path, sharing, grammar) {
+    const parentPath = path.slice(0, -1);
+    const index = path[path.length - 1];
+    // The path-addressed door, so the commit's id ledger sees the slot go.
+    const chain = ensureUnsharedPath(doc, parentPath, sharing);
+    deleteAtPath(doc, path, sharing);
+    if (chain.length > 0)
+        rebuildUnsharedChain(doc, chain, sharing, null, grammar);
+    const survivors = (chain.length > 0 ? chain[chain.length - 1] : doc).children ?? [];
+    const landing = Math.max(0, Math.min(index, survivors.length - 1));
+    return { newDoc: doc, collapsedCaret: { path: [...parentPath, landing], offset: 0 } };
+}
 /**
  * Delete [start, end] in place, merge at start's position with its container context preserved,
  * cascade-clean empty ancestors, rebuild container raws. Copy-path-on-write: every spliced or
@@ -38,6 +57,15 @@ export function rangeDelete(doc, start, end, sharing, grammar, presentationMode,
     const endRaw = endBlock.raw;
     const startOffset = charOffsetOf(start, 'rangeDelete:prose-merge-start');
     const endOffset = charOffsetOf(end, 'rangeDelete:prose-merge-end');
+    // The range holds one block whole, so none of its own bytes survive: the byte arm below would
+    // keep a husk holding a bare line ending, which no reload reads as that kind. A paragraph is
+    // the one kind that survives empty, because a blank one IS the separating line below it.
+    if (sameBlock &&
+        startOffset === 0 &&
+        endOffset >= displayLength(startRaw) &&
+        !isBlankParagraph({ kind: startBlock.kind, raw: '' })) {
+        return deleteWholeUnit(doc, start.path, sharing, grammar);
+    }
     // The end slice answers to the END block's rule before the join: start's rule below speaks
     // only for start's bytes, so a truncation from the end block's head strands its closer. A
     // same-block merge is one block's bytes and takes that rule once, whole, on the arm below.
@@ -110,7 +138,7 @@ export function rangeDelete(doc, start, end, sharing, grammar, presentationMode,
 /** The container prefix the survivor renders under, so the join seam can read its candidate back
  *  through it (live-mode.md § 4.5). An ambient marker rides the container's FIRST child only, the
  *  way `BlockList` forwards it, and a list item is the one built-in container that paints one. */
-function containerAmbientPrefix(doc, path) {
+export function containerAmbientPrefix(doc, path) {
     if (path.length < 2 || path[path.length - 1] !== 0)
         return '';
     const parent = blockNodeAt(doc, path.slice(0, -1));

package/dist/selection/selection-drop.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Dragging a selection and dropping it. The browser's own version is two native edits committed
+ * apart — `deleteByDrag` on the source, `insertFromDrop` on the target — so undo takes two presses
+ * over a document that lost bytes in between, and inside one block the source commit rebuilds the
+ * surface under the drop. Owned here instead: one snapshot over two raw writes, which splice
+ * nothing, so no path moves under the second.
+ */
+import type { Document } from '../core/nodes';
+import type { GrammarView } from '../schema/block-openers';
+import type { LinkReferenceResolverRef, PresentationModeGetter } from '../editor-keys';
+import type { PluginActivation } from '../schema/plugin-activation';
+import type { CommitController } from '../action-contracts';
+import type { PasteCommitCoordinator } from '../tree-operations/paste/paste-deps';
+import { type EditorEvents } from '../editor-events';
+export interface SelectionDropDeps {
+    editorRoot: HTMLElement;
+    getDoc(): Document;
+    controller: CommitController;
+    coordinator: PasteCommitCoordinator;
+    getPresentationMode: PresentationModeGetter | undefined;
+    linkRef: LinkReferenceResolverRef | undefined;
+    grammar: GrammarView | undefined;
+    activePlugins: PluginActivation | undefined;
+    /** The instance event surface: a ceremony that throws mid-move has nowhere else to report. */
+    events: EditorEvents;
+    isReadOnly(): boolean;
+}
+export declare function installSelectionDrop(deps: SelectionDropDeps): () => void;
+/** Where a splice of `delta` blocks at `at` inside `parent` leaves `target`: what the drop's
+ *  second write addresses once the first one's reparse changed its slot's block count. */
+export declare function shiftPathAfterSplice(target: number[], parent: number[], at: number, delta: number): number[];
+/** Where a drop at `offset` lands once `[start, end)` left the same block, `shrunkBy` bytes
+ *  shorter than the range was wide once the join seam cleaned up. Null inside the range. */
+export declare function dropOffsetAfterCut(offset: number, start: number, end: number, shrunkBy: number): number | null;

package/dist/selection/selection-drop.js

@@ -0,0 +1,253 @@
+/**
+ * Dragging a selection and dropping it. The browser's own version is two native edits committed
+ * apart — `deleteByDrag` on the source, `insertFromDrop` on the target — so undo takes two presses
+ * over a document that lost bytes in between, and inside one block the source commit rebuilds the
+ * surface under the drop. Owned here instead: one snapshot over two raw writes, which splice
+ * nothing, so no path moves under the second.
+ */
+import { emitClipboardError } from '../editor-events';
+import { ambientLengthOf } from '../ambient/ambient-dom';
+import { toClampedRawOffset } from '../cursor/coordinate-spaces';
+import { domTextOffsetAtNode } from '../cursor/widget-offset';
+import { trailingLineEnding, trimTrailingLineEnding } from '../core/lines';
+import { replaceRangeRaw } from '../components/blocks/text/live-selection-edit';
+import { blockNodeAt, emptyParagraph, writeOwnRaw } from '../tree-operations/node-primitives';
+import { cloneNode } from '../tree-operations/clone';
+import { cutRangeFromDisplay } from '../tree-operations/node-ops';
+import { rebuildAncestryRaw } from '../schema/container-raw';
+import { applyPasteTransforms } from '../tree-operations/paste/paste-transforms';
+import { replaceBlockAtParent } from '../tree-operations/paste/replace-block-at-parent';
+import { parseReplacement } from '../tree-operations/paste/replacement-parse';
+import { blockNearPoint } from './nearest-block';
+import { findSurfaceForElement } from './path-lookup';
+import { containerAmbientPrefix } from './range-delete';
+/** A drag that IS this gesture but whose shape the seam does not move — a range leaving its
+ *  surface, an empty one. The drop cancels it rather than handing it back. */
+const DECLINED = 'declined';
+// ── Public entry ───────────────────────────────────────────────────────────
+export function installSelectionDrop(deps) {
+    let source = null;
+    const onDragStart = (e) => {
+        source = readSelectionSource(deps.editorRoot, e.target);
+    };
+    const onDragEnd = () => {
+        source = null;
+    };
+    // The editor is the drop target for every drag this seam recognized, declined ones included:
+    // the drop below must RUN to cancel the browser's pair of native edits.
+    const onDragOver = (e) => {
+        if (source)
+            e.preventDefault();
+    };
+    const onDrop = (e) => {
+        const from = source;
+        source = null;
+        if (!from)
+            return;
+        // Before every decline below, not after: the browser's two edits land apart and its undo
+        // is not ours, so a shape this seam declines mutates nothing rather than half of it.
+        e.preventDefault();
+        if (from === DECLINED || deps.isReadOnly())
+            return;
+        const target = dropTarget(deps, e.clientX, e.clientY);
+        if (!target)
+            return;
+        const text = movedText(deps, from);
+        if (text === null)
+            return;
+        void runDrop(deps, from, target, text, e.ctrlKey || e.altKey).catch((error) => {
+            // A throw between the two writes leaves a snapshot pushed and half the move applied;
+            // the host hears it on the channel the paste route reports through.
+            emitClipboardError(deps.events, { error, path: from.path });
+        });
+    };
+    deps.editorRoot.addEventListener('dragstart', onDragStart);
+    deps.editorRoot.addEventListener('dragend', onDragEnd);
+    deps.editorRoot.addEventListener('dragover', onDragOver);
+    deps.editorRoot.addEventListener('drop', onDrop);
+    return () => {
+        deps.editorRoot.removeEventListener('dragstart', onDragStart);
+        deps.editorRoot.removeEventListener('dragend', onDragEnd);
+        deps.editorRoot.removeEventListener('dragover', onDragOver);
+        deps.editorRoot.removeEventListener('drop', onDrop);
+    };
+}
+/** Where a splice of `delta` blocks at `at` inside `parent` leaves `target`: what the drop's
+ *  second write addresses once the first one's reparse changed its slot's block count. */
+export function shiftPathAfterSplice(target, parent, at, delta) {
+    if (delta === 0 || target.length <= parent.length)
+        return target;
+    for (let i = 0; i < parent.length; i++)
+        if (target[i] !== parent[i])
+            return target;
+    if (target[parent.length] <= at)
+        return target;
+    const shifted = target.slice();
+    shifted[parent.length] += delta;
+    return shifted;
+}
+/** Where a drop at `offset` lands once `[start, end)` left the same block, `shrunkBy` bytes
+ *  shorter than the range was wide once the join seam cleaned up. Null inside the range. */
+export function dropOffsetAfterCut(offset, start, end, shrunkBy) {
+    if (offset > start && offset < end)
+        return null;
+    return offset <= start ? offset : Math.max(0, offset - shrunkBy);
+}
+// ── Reading the gesture ────────────────────────────────────────────────────
+/**
+ * The native range the drag carries, in its surface's raw offsets. `null` is "not this gesture" and
+ * leaves the drag to the browser; {@link DECLINED} is this gesture in a shape the seam does not
+ * move, which the drop cancels. A cross-block selection reaches neither: it paints through the
+ * overlay and leaves no native range for the browser to drag.
+ */
+function readSelectionSource(editorRoot, dragged) {
+    const sel = window.getSelection();
+    if (!sel || sel.isCollapsed || sel.rangeCount === 0)
+        return null;
+    const range = sel.getRangeAt(0);
+    // A draggable of its own (a rendered link, an image) is not this gesture, even with a range
+    // painted elsewhere: a selection drag grips a node the range covers.
+    if (!(dragged instanceof Node) || !range.intersectsNode(dragged))
+        return null;
+    const surface = surfaceOf(range.startContainer);
+    if (!surface || !editorRoot.contains(surface))
+        return null;
+    // Past this point the drag IS the editor's selection, so every remaining shape declines.
+    if (!surface.contains(range.endContainer))
+        return DECLINED;
+    const found = findSurfaceForElement(surface);
+    if (!found)
+        return DECLINED;
+    const ambient = ambientLengthOf(surface);
+    const start = toClampedRawOffset(domTextOffsetAtNode(surface, range.startContainer, range.startOffset), ambient);
+    const end = toClampedRawOffset(domTextOffsetAtNode(surface, range.endContainer, range.endOffset), ambient);
+    return start < end ? { ...found, start, end } : DECLINED;
+}
+/** The block and offset a drop point addresses, as a single-click caret would land. Null where
+ *  the point names no character position (a whole-block unit, a table cell). */
+function dropTarget(deps, clientX, clientY) {
+    const near = blockNearPoint(deps.editorRoot, clientX, clientY);
+    const point = near?.endpointHere();
+    if (!point || !('offset' in point) || point.cellCoordinate)
+        return null;
+    return blockNodeAt(deps.getDoc(), point.path) ? { path: point.path, offset: point.offset } : null;
+}
+/** The source surface's own bytes for the range, past the paste transforms. Null for a payload
+ *  this seam does not own: a line break needs the structural paste route. */
+function movedText(deps, from) {
+    const node = blockNodeAt(deps.getDoc(), from.path);
+    if (!node)
+        return null;
+    const raw = trimTrailingLineEnding(node.raw).slice(from.start, from.end);
+    const text = applyPasteTransforms(raw, deps.activePlugins);
+    return text && !/[\r\n]/.test(text) ? text : null;
+}
+// ── The commit ceremony ────────────────────────────────────────────────────
+async function runDrop(deps, from, to, text, copy) {
+    if (copy) {
+        await writeBlockRaw(deps, to.path, insert(to.offset, text), to.offset + text.length, true);
+        return;
+    }
+    const cut = cutFrom(deps, from);
+    if (!cut)
+        return;
+    if (pathsEqual(cut.path, to.path)) {
+        const offset = dropOffsetAfterCut(to.offset, from.start, from.end, cut.shrunkBy);
+        if (offset === null)
+            return;
+        const merged = spliceAt(cut.raw, offset, text);
+        await writeBlockRaw(deps, cut.path, () => merged, offset + text.length, true);
+        return;
+    }
+    deps.controller.pushUndoSnapshotPath(from.path, from.start);
+    // A table's caret door reads a cell landing, never a character offset (G1.29), so the
+    // transient caret the second write moves off is its first cell.
+    const sourceCaret = from.inCell ? 0 : from.start;
+    const spliced = await writeBlockRaw(deps, cut.path, () => cut.raw, sourceCaret, false);
+    const at = cut.path[cut.path.length - 1];
+    const target = shiftPathAfterSplice(to.path, cut.path.slice(0, -1), at, spliced);
+    await writeBlockRaw(deps, target, insert(to.offset, text), to.offset + text.length, false);
+}
+function insert(offset, text) {
+    return (raw) => spliceAt(raw, offset, text);
+}
+/** The source surface's display bytes with the dragged range gone, through the delete seam so a
+ *  live-mode join cleans up after itself. */
+function cutFrom(deps, from) {
+    const node = blockNodeAt(deps.getDoc(), from.path);
+    if (!node)
+        return null;
+    if (from.inCell)
+        return cutFromCell(deps, from, node);
+    const before = trimTrailingLineEnding(node.raw);
+    const edit = replaceRangeRaw(node, { start: from.start, end: from.end }, '', deps.getPresentationMode?.(), deps.linkRef, containerAmbientPrefix(deps.getDoc(), from.path));
+    const raw = trimTrailingLineEnding(edit.raw);
+    return { path: from.path, raw, shrunkBy: before.length - raw.length };
+}
+/** A cell's bytes are joined into its row, so the TABLE is the block the cut rewrites: the cell's
+ *  own range-delete on a copy, then the kind's escape and the ancestry rebuild around it. */
+function cutFromCell(deps, from, cell) {
+    const tablePath = from.path.slice(0, -2);
+    // The cell path is resolved from a DOM selector contract, so the kind is read, not assumed.
+    const table = blockNodeAt(deps.getDoc(), tablePath);
+    if (!table || table.kind !== 'table')
+        return null;
+    const cut = cutRangeFromDisplay(cell, cell.raw, { start: from.start, end: from.end }, deps.getPresentationMode?.(), deps.linkRef);
+    const rebuilt = cloneNode(table);
+    const inner = from.path.slice(-2);
+    const [rowIdx, colIdx] = inner;
+    const written = rebuilt.children?.[rowIdx]?.children?.[colIdx];
+    if (!written)
+        return null;
+    writeOwnRaw(written, cut.display, deps.grammar);
+    rebuildAncestryRaw(rebuilt, inner);
+    const raw = trimTrailingLineEnding(rebuilt.raw);
+    return { path: tablePath, raw, shrunkBy: trimTrailingLineEnding(table.raw).length - raw.length };
+}
+/**
+ * Replace the block at `path` with the reparse of the bytes `rewrite` returns, at its parent
+ * scope. Answers how many blocks the slot grew or shrank by, which is what keeps a second
+ * write's path honest. `own` pushes this write's own undo entry.
+ */
+async function writeBlockRaw(deps, path, rewrite, caret, own) {
+    const doc = deps.getDoc();
+    const node = blockNodeAt(doc, path);
+    if (!node)
+        return 0;
+    const written = rewrite(trimTrailingLineEnding(node.raw));
+    // A block emptied by the cut keeps its slot as a blank paragraph: no splice, so the second
+    // write's path is still the one this gesture resolved.
+    const parsed = parseReplacement(node, written, deps.grammar, () => [
+        emptyParagraph(node.leadingTrivia ?? '', trailingLineEnding(node.raw))
+    ]);
+    if (!parsed)
+        return 0;
+    const landed = await replaceBlockAtParent({
+        doc,
+        blockPath: path,
+        replacement: parsed.replacement,
+        controller: deps.coordinator,
+        undoEntry: own ? 'own' : 'join',
+        focusReplacementIndex: parsed.replacement.length - 1,
+        focusOffset: caret,
+        source: 'selection-drop',
+        ...(deps.grammar ? { grammar: deps.grammar } : {})
+    });
+    // The LANDED count, not the parse's: a body rule inside the scope can rewrite the list. Zero
+    // is the unmounted-scope decline, which wrote nothing and so moved nothing.
+    return Math.max(0, landed - 1);
+}
+// ── Small helpers ──────────────────────────────────────────────────────────
+function spliceAt(raw, offset, text) {
+    const at = Math.max(0, Math.min(offset, raw.length));
+    return raw.slice(0, at) + text + raw.slice(at);
+}
+function pathsEqual(a, b) {
+    return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+function surfaceOf(node) {
+    let el = node instanceof HTMLElement ? node : node.parentElement;
+    while (el && el.contentEditable !== 'true')
+        el = el.parentElement;
+    return el;
+}

package/dist/selection/selection-restore.js

@@ -5,7 +5,7 @@
  * can't be carried by only one. A gap caret takes {@link restoreGapCaret}, the same road minus
  * the endpoint pair.
  */
-import { isBlockNode, nodeAt } from '../tree-operations/node-ops';
+import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
 import { applySelectionToDom } from './native-bridge';
 import { placeGapCaret } from './caret-doors';
 import { gapScopeChildren } from './gap-caret';

package/dist/selection/selection-state.svelte.d.ts

@@ -34,6 +34,12 @@ export interface SelectionState {
     readonly selectAllCount: number;
     /** The third mode: a collapsed caret in a between-blocks boundary (`gap-caret.ts`). */
     readonly gapCaret: GapCaretPosition | null;
+    /**
+     * One block taken whole as the entire range — a press on a surface-less leaf (an equation)
+     * dragged inside it. The stored pair spans the block's bytes on a shared path, which the
+     * same-path guard would otherwise refuse, so the overlay reads this to paint it as a unit.
+     */
+    readonly wholeUnitPath: number[] | null;
     enterCrossBlock(anchor: SelectionEndpoint, focus: SelectionEndpoint): void;
     extendFocus(point: SelectionEndpoint): void;
     collapse(): void;

package/dist/selection/selection-state.svelte.js

@@ -4,11 +4,12 @@
  * native browser selection rules, and the two are mutually exclusive here rather than at any
  * call site. Transitions: `docs/design/editor.md` § Cross-block selection.
  */
-import { nodeAt } from '../tree-operations/node-ops';
+import { nodeAt } from '../tree-operations/node-primitives';
 import { isWholeBlockEndpoint, normalize } from './primitives';
 import { cellEndpointDeepPath, normalizeTableEndpoint, snapCrossBlockTableEndpoints } from './table-endpoint-snap';
 import { normalizeCharEndpoint } from './char-endpoint-snap';
 import { pathsEqual } from './path-math';
+import { displayLength } from '../core/lines';
 import { assertInvariant } from '../assert';
 import { checkCrossBlockEndpointCoordinates } from '../invariants/selection-endpoints';
 export function createSelectionState(options) {
@@ -19,6 +20,7 @@ class SelectionStateImpl {
     #anchor = $state(null);
     #focus = $state(null);
     #gapCaret = $state(null);
+    #wholeUnit = $state(null);
     #selectAllCount = $state(0);
     #onChange;
     #getDoc;
@@ -63,6 +65,9 @@ class SelectionStateImpl {
     get isCrossBlock() {
         return this.#anchor !== null && this.#focus !== null;
     }
+    get wholeUnitPath() {
+        return this.#wholeUnit?.slice() ?? null;
+    }
     get isCustomRendered() {
         const getDoc = this.#getDoc;
         if (!getDoc)
@@ -71,6 +76,8 @@ class SelectionStateImpl {
         const focus = this.#focus;
         if (!anchor || !focus)
             return false;
+        if (this.#wholeUnit)
+            return true;
         if (!pathsEqual(anchor.path, focus.path))
             return true;
         if (anchor.offset === focus.offset)
@@ -102,6 +109,19 @@ class SelectionStateImpl {
     }
     enterCrossBlock(anchor, focus) {
         this.#gapCaret = null;
+        // Both ends the same surface-less block: the unit itself is the range, stored as its full
+        // byte span and flagged, since below a same-path pair is refused as prose.
+        if (isWholeBlockEndpoint(anchor) &&
+            isWholeBlockEndpoint(focus) &&
+            pathsEqual(anchor.path, focus.path)) {
+            const path = anchor.path.slice();
+            this.#anchor = { path, offset: 0 };
+            this.#focus = { path: path.slice(), offset: this.#byteLengthAt(path) };
+            this.#wholeUnit = path.slice();
+            this.#notify();
+            return;
+        }
+        this.#wholeUnit = null;
         const a = this.#normalizePoint(anchor, focus.path);
         const f = this.#normalizePoint(focus, anchor.path);
         // A same-path prose pair is a single-block range the browser owns; storing it mints an
@@ -124,6 +144,13 @@ class SelectionStateImpl {
             throw new Error('SelectionState.extendFocus called without an anchor');
         }
         this.#gapCaret = null;
+        // Leaving a whole unit: its anchor is the block as a whole again, so the side it means
+        // (start below the new focus, end above it) is resolved afresh rather than kept at 0.
+        if (this.#wholeUnit) {
+            const unit = { path: this.#wholeUnit, wholeBlock: true };
+            this.#anchor = this.#normalizePoint(unit, point.path);
+            this.#wholeUnit = null;
+        }
         const f = this.#normalizePoint(point, this.#anchor.path);
         // A focus back on the anchor's prose leaf contracts to a single-block range. No
         // `offset !== offset` guard, unlike #isSamePathProseRange: extendFocus never seeds, so
@@ -142,6 +169,11 @@ class SelectionStateImpl {
     }
     // G1.29 at the storing seam, the belt behind #normalizePoint: both entries carry it because
     // both store an endpoint pair.
+    #byteLengthAt(path) {
+        const doc = this.#getDoc?.();
+        const node = doc ? nodeAt(doc, path) : null;
+        return node && 'raw' in node ? displayLength(node.raw) : 0;
+    }
     #assertEndpointCoordinates(anchor, focus) {
         const getDoc = this.#getDoc;
         if (!getDoc)
@@ -177,6 +209,7 @@ class SelectionStateImpl {
         this.#anchor = null;
         this.#focus = null;
         this.#gapCaret = null;
+        this.#wholeUnit = null;
         this.#notify();
     }
     clear() {
@@ -185,6 +218,7 @@ class SelectionStateImpl {
         this.#anchor = null;
         this.#focus = null;
         this.#gapCaret = null;
+        this.#wholeUnit = null;
         this.#selectAllCount = 0;
         this.#notify();
     }
@@ -198,6 +232,7 @@ class SelectionStateImpl {
     setGapCaret(pos) {
         this.#anchor = null;
         this.#focus = null;
+        this.#wholeUnit = null;
         this.#gapCaret = { parentPath: pos.parentPath.slice(), index: pos.index };
         this.#notify();
     }

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

@@ -5,7 +5,7 @@
  * An intra-table pair is deliberately left unsnapped, so rectangular sub-cell selection survives.
  */
 import { metadataOf } from '../core/nodes';
-import { isBlockNode, nodeAt } from '../tree-operations/node-ops';
+import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
 import { cellIndexOf } from './primitives';
 import { asCellIndex, cellRowCol } from '../cursor/coordinate-spaces';
 import { comparePaths, pathHasPrefix } from './path-math';