@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/selection/selection-drop.js

@@ -1,79 +1,124 @@
 /**
- * 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.
+ * Dragging a selection and dropping it, as one undo entry over two raw writes (the cut, then
+ * the insert). The browser's own drag is two separate edits, which undo would take in two steps.
  */
 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 { rawOffsetAt, rawRangeToDomRange } from '../cursor/widget-offset';
+import { documentLineEnding, trailingLineEnding, trimTrailingLineEnding } from '../core/lines';
+import { blockContentElAt } from '../components/block-el-lookup';
+import { blockNodeAt, emptyParagraph, normalizeOwnRaw, writeOwnRaw } from '../tree-operations/node-primitives';
 import { cloneNode } from '../tree-operations/clone';
-import { cutRangeFromDisplay } from '../tree-operations/node-ops';
+import { replaceRangeInLeaf } from '../tree-operations/leaf-range';
 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 { slotReaderAt } from '../tree-operations/list/task-paragraph';
 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. */
+import { charOffsetOf } from './primitives';
+import { storedAsAt } from '../tree-operations/stored-as';
+import { docPathFrom } from '../cursor/coordinate-spaces';
+/** A drag of the editor's selection in a shape the drop can't move (leaving its element, empty,
+ *  holding a line break); the drop cancels it rather than handing it back to the browser. */
 const DECLINED = 'declined';
 // ── Public entry ───────────────────────────────────────────────────────────
 export function installSelectionDrop(deps) {
     let source = null;
+    // Where the painted caret stands. A drag fires `dragover` over and over at one position,
+    // and only a move to a different drop point has a new caret to draw.
+    let caretAt = null;
+    function hideCaret() {
+        if (!caretAt)
+            return;
+        caretAt = null;
+        deps.setDropCaret(null);
+    }
+    /** The caret saying where a release would land: cancelling the browser's drop takes its own
+     *  caret away, so the editor's stands where the drop would land and declines where it does. */
+    function drawCaretAt(clientX, clientY, copy) {
+        const from = source;
+        if (!from || from === DECLINED || deps.isReadOnly())
+            return hideCaret();
+        const target = dropTarget(deps, clientX, clientY);
+        if (!target)
+            return hideCaret();
+        // The same refusal `dropOffsetAfterCut` makes once the cut has shrunk the block, tested
+        // here before the cut: a move has nowhere to put bytes inside the range it took them from.
+        const inside = pathsEqual(target.path, from.path) && insideRange(target.offset, from.start, from.end);
+        if (inside && !copy) {
+            return hideCaret();
+        }
+        if (caretAt && caretAt.offset === target.offset && pathsEqual(caretAt.path, target.path)) {
+            return;
+        }
+        const rect = dropCaretRect(deps.editorRoot, target.path, target.offset);
+        if (!rect)
+            return hideCaret();
+        caretAt = target;
+        deps.setDropCaret(rect);
+    }
     const onDragStart = (e) => {
-        source = readSelectionSource(deps.editorRoot, e.target);
+        source = readSelectionSource(deps, e.target);
     };
     const onDragEnd = () => {
         source = null;
+        hideCaret();
     };
-    // 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.
+    // The editor is the drop target for every drag recognised here, declined ones included: the
+    // drop handler below must run to cancel the browser's pair of native edits.
     const onDragOver = (e) => {
-        if (source)
-            e.preventDefault();
+        if (!source)
+            return;
+        e.preventDefault();
+        drawCaretAt(e.clientX, e.clientY, isCopyDrag(e));
+    };
+    // `dragleave` also fires for every child the pointer crosses, so the caret goes only once
+    // the point is outside the editor's own box.
+    const onDragLeave = (e) => {
+        if (source && !isInside(deps.editorRoot, e.clientX, e.clientY))
+            hideCaret();
     };
     const onDrop = (e) => {
         const from = source;
         source = null;
+        hideCaret();
         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.
+        // Before every decline below, not after: the browser's two edits land separately and its
+        // undo is not the editor's, so a declined shape changes 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.
+        void runDrop(deps, from, target, isCopyDrag(e)).catch((error) => {
+            // A throw between the two writes leaves half the move applied; the host hears about it on
+            // the same channel paste errors use.
             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('dragleave', onDragLeave);
     deps.editorRoot.addEventListener('drop', onDrop);
     return () => {
+        // A reinstall mid-drag hands the new listeners no caret to clear, so it goes here.
+        hideCaret();
         deps.editorRoot.removeEventListener('dragstart', onDragStart);
         deps.editorRoot.removeEventListener('dragend', onDragEnd);
         deps.editorRoot.removeEventListener('dragover', onDragOver);
+        deps.editorRoot.removeEventListener('dragleave', onDragLeave);
         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. */
+/** Ctrl, or Alt (Option, macOS's copy key for a drag): the release copies instead of moving. */
+function isCopyDrag(e) {
+    return e.ctrlKey || e.altKey;
+}
+/** Where `target` ends up after a splice of `delta` blocks at `at` inside `parent`: what the
+ *  drop's second write addresses once the first write's reparse changed the block count. */
 export function shiftPathAfterSplice(target, parent, at, delta) {
     if (delta === 0 || target.length <= parent.length)
         return target;
@@ -86,42 +131,40 @@ export function shiftPathAfterSplice(target, parent, at, delta) {
     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. */
+/** Where a drop at `offset` lands once `[start, end)` has left the same block, which shrank by
+ *  `shrunkBy` bytes after the join cleanup. Null inside the range. */
 export function dropOffsetAfterCut(offset, start, end, shrunkBy) {
-    if (offset > start && offset < end)
+    if (insideRange(offset, start, 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) {
+/** The native range the drag carries, in raw offsets: null leaves the drag to the browser, and
+ *  {@link DECLINED} is the editor's selection in a shape the drop cancels. */
+function readSelectionSource(deps, 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.
+    // An element that is draggable on its own (a rendered link, an image) is not this gesture,
+    // even with a range painted elsewhere: a selection drag starts on a node the range covers.
     if (!(dragged instanceof Node) || !range.intersectsNode(dragged))
         return null;
     const surface = surfaceOf(range.startContainer);
-    if (!surface || !editorRoot.contains(surface))
+    if (!surface || !deps.editorRoot.contains(surface))
         return null;
-    // Past this point the drag IS the editor's selection, so every remaining shape declines.
+    // From here the drag is the editor's selection, so every remaining shape is declined.
     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;
+    const start = rawOffsetAt(surface, range.startContainer, range.startOffset);
+    const end = rawOffsetAt(surface, range.endContainer, range.endOffset);
+    if (start >= end)
+        return DECLINED;
+    const text = movedText(deps, { ...found, start, end });
+    return text === null ? DECLINED : { ...found, start, end, text };
 }
 /** 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). */
@@ -132,8 +175,25 @@ function dropTarget(deps, clientX, clientY) {
         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. */
+/** Viewport rect of the caret at `offset` in the block at `path`. A block whose offset names no
+ *  text position falls back to its own box, and an unmounted one to null. */
+function dropCaretRect(root, path, offset) {
+    const el = blockContentElAt(root, path);
+    if (!el)
+        return null;
+    const at = charOffsetOf({ path, offset }, 'selection-drop:caret');
+    const rect = rawRangeToDomRange(el, at, at)?.getBoundingClientRect();
+    if (rect && rect.height > 0)
+        return { left: rect.left, top: rect.top, height: rect.height };
+    const box = el.getBoundingClientRect();
+    return box.height > 0 ? { left: box.left, top: box.top, height: box.height } : null;
+}
+function isInside(el, clientX, clientY) {
+    const box = el.getBoundingClientRect();
+    return clientX >= box.left && clientX <= box.right && clientY >= box.top && clientY <= box.bottom;
+}
+/** The source element's bytes for the range, after the paste transforms. Null for text this
+ *  module does not handle: a line break needs the structural paste path. */
 function movedText(deps, from) {
     const node = blockNodeAt(deps.getDoc(), from.path);
     if (!node)
@@ -142,10 +202,15 @@ function movedText(deps, from) {
     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) {
+// ── The commit ─────────────────────────────────────────────────────────────
+export function runDrop(deps, from, to, copy) {
+    // One entry for the cut and the insert, and none when neither lands.
+    return deps.controller.undoStep({ path: docPathFrom(from.path), offset: from.start }, () => moveOrCopy(deps, from, to, copy));
+}
+async function moveOrCopy(deps, from, to, copy) {
+    const text = from.text;
     if (copy) {
-        await writeBlockRaw(deps, to.path, insert(to.offset, text), to.offset + text.length, true);
+        await writeBlockRaw(deps, to.path, insert(to.offset, text), to.offset + text.length);
         return;
     }
     const cut = cutFrom(deps, from);
@@ -156,23 +221,25 @@ async function runDrop(deps, from, to, text, copy) {
         if (offset === null)
             return;
         const merged = spliceAt(cut.raw, offset, text);
-        await writeBlockRaw(deps, cut.path, () => merged, offset + text.length, true);
+        await writeBlockRaw(deps, cut.path, () => merged, offset + text.length);
         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.
+    // A table's `focus` takes a cell, never a character offset, so the temporary caret the second
+    // write moves away from is its first cell (G1.29).
     const sourceCaret = from.inCell ? 0 : from.start;
-    const spliced = await writeBlockRaw(deps, cut.path, () => cut.raw, sourceCaret, false);
+    const spliced = await writeBlockRaw(deps, cut.path, () => cut.raw, sourceCaret);
+    // An insert after a cut that never landed would turn the move into a copy.
+    if (spliced === null)
+        return;
     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);
+    await writeBlockRaw(deps, target, insert(to.offset, text), to.offset + text.length);
 }
 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. */
+/** The source element's display bytes with the dragged range gone, cut as any in-leaf edit is so
+ *  a live-mode join cleans up after itself. */
 function cutFrom(deps, from) {
     const node = blockNodeAt(deps.getDoc(), from.path);
     if (!node)
@@ -180,68 +247,65 @@ function cutFrom(deps, from) {
     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 store = storedAsAt(deps.getDoc(), from.path, deps.reading);
+    const edit = replaceRangeInLeaf(node, { start: from.start, end: from.end }, '', store);
     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. */
+/** A cell's bytes are joined into its row, so the table is the block the cut rewrites: the cell's
+ *  own cut on a copy, then the kind's escaping and the ancestor 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 store = storedAsAt(deps.getDoc(), from.path, deps.reading);
+    const cut = replaceRangeInLeaf(cell, { start: from.start, end: from.end }, '', store);
     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);
+    writeOwnRaw(written, trimTrailingLineEnding(cut.raw), documentLineEnding(deps.getDoc()), deps.reading.grammar);
+    rebuildAncestryRaw(rebuilt, inner, deps.reading.grammar);
     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) {
+/** Replaces the block at `path` with the reparse of `rewrite`'s bytes. Returns the change in block
+ *  count at that position, so a second write's path stays right, or null when nothing landed. */
+async function writeBlockRaw(deps, path, rewrite, caret) {
     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))
+        return null;
+    // The bytes are built outside the block's own element, so the kind's write rule runs here.
+    const lineEnding = documentLineEnding(doc);
+    const written = normalizeOwnRaw(node, rewrite(trimTrailingLineEnding(node.raw)), lineEnding);
+    // A block emptied by the cut keeps its position as a blank paragraph: no splice, so the
+    // second write's path is still the one resolved at the drop.
+    const read = slotReaderAt(doc, path, deps.reading.grammar);
+    const parsed = parseReplacement(node, written, lineEnding, read, () => [
+        emptyParagraph(node.leadingTrivia ?? '', trailingLineEnding(node.raw, lineEnding))
     ]);
     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);
+        return null;
+    const landed = await deps.coordinator.replaceBlock(path, parsed.replacement, { replacementIndex: parsed.replacement.length - 1, offset: caret }, 
+    // The drop's undo step records the selection, so this offset is never read.
+    { source: 'selection-drop', snapshotOffset: 0 });
+    // The count that landed, not the parse's: a container's body rule can rewrite the list.
+    return landed === null ? null : 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);
 }
+/** Strictly between `start` and `end`: a position the dragged range itself covers. */
+function insideRange(offset, start, end) {
+    return offset > start && offset < end;
+}
 function pathsEqual(a, b) {
     return a.length === b.length && a.every((v, i) => v === b[i]);
 }

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

@@ -1,46 +1,33 @@
 /**
- * The one road from a stored selection back onto the live editor: resolve against the current
- * tree, reveal what the caret will be parked at, then land it. Both entry paths (undo/redo
- * swap, the consumer's `setSelection`) funnel through here, so the resolve/clamp/reveal rules
- * can't be carried by only one. A gap caret takes {@link restoreGapCaret}, the same road minus
- * the endpoint pair.
+ * The checks a stored selection passes before it goes back onto the live editor: each endpoint
+ * resolved against the current tree and clamped into its block. `caret-landing.ts :: restore` puts
+ * every stored selection back, a gap caret through {@link restoreGapCaret}.
  */
 import type { DocumentView } from '../core/node-views';
-import type { BlockElLookup } from '../editor-keys';
-import type { EditorSelection, SelectionPoint } from './primitives';
+import type { BlockComponent } from '../block-component';
+import { type SelectionPoint } from './primitives';
 import { type GapCaretPosition } from './gap-caret';
 import type { SelectionState } from './selection-state.svelte';
+import type { CaretMemory } from '../cursor/caret-memory';
 /**
  * `unresolvable` is decided before anything happens and is the only outcome that leaves the
- * editor untouched. `unplaced` is everything short of both halves landing; the reveal and, on
- * the custom route, the cross-block state write have already run.
+ * editor untouched. `unplaced` is everything short of both halves landing; the mount and, on
+ * the overlay route, the cross-block state write have already run.
  */
 export type SelectionRestoreOutcome = 'applied' | 'unresolvable' | 'unplaced';
-export interface SelectionRestoreDeps {
+export interface GapCaretRestoreDeps {
     getDoc(): DocumentView;
     selectionState: SelectionState;
-    getBlockElByPath: BlockElLookup;
-    /** Make the park target ready and report whether it is. Injected because WHICH path gets
-     *  revealed is this module's rule, how strongly is the caller's. */
-    revealTarget(path: number[]): Promise<boolean>;
+    /** Mounts the block at `path`: the caret landing's `mount`. */
+    mount(path: number[]): Promise<BlockComponent | null>;
+    /** Brings the mounted block into view as the restore's reveal policy says. */
+    reveal(path: number[]): Promise<void>;
+    /** Cleared on each restore, since a placed caret did not arrive by a key. */
+    caretMemory: Pick<CaretMemory, 'forget'>;
 }
-/**
- * Restore a snapshot. Never throws; an endpoint whose path no longer addresses a block is
- * declined before the reveal, so a dead snapshot cannot move the viewport or disturb a live
- * selection. What a decline does about the on-screen selection is the caller's policy.
- */
-export declare function restoreSelection(selection: EditorSelection, deps: SelectionRestoreDeps): Promise<SelectionRestoreOutcome>;
-/**
- * Restore a gap caret. The scope check is `gapEligibleAt`'s, not a full eligibility gate:
- * the tree being restored is the one the gap was minted against, so `gapEdges` cannot have
- * changed under it, but the PATH can now name something no BlockList renders.
- */
-export declare function restoreGapCaret(pos: GapCaretPosition, deps: SelectionRestoreDeps): Promise<SelectionRestoreOutcome>;
-/**
- * Clamp an endpoint into its block's addressable range, or null when its path no longer
- * resolves to a block (the document root included). The NODE KIND picks the coordinate space,
- * not the `cellCoordinate` flag: an intra-table endpoint is unflagged (see
- * {@link SelectionPoint}) yet still carries a cell index. The char-space bound is `raw`, which
- * on a marker-bearing kind runs past the content end; the DOM walk lands such an offset there.
- */
+/** Restores a gap caret with only the child-list check: the tree is the one the gap was made
+ *  against, so its `gapEdges` hold, but the path may name something no BlockList renders. */
+export declare function restoreGapCaret(pos: GapCaretPosition, deps: GapCaretRestoreDeps): Promise<SelectionRestoreOutcome>;
+/** Clamps an endpoint into its block's whole `raw`, markers included, or null when its path names
+ *  no block. An offset on a table path comes back flagged as a cell index, even a plain one. */
 export declare function resolveSelectionPoint(doc: DocumentView, point: SelectionPoint): SelectionPoint | null;

package/dist/selection/selection-restore.js

@@ -1,66 +1,43 @@
 /**
- * The one road from a stored selection back onto the live editor: resolve against the current
- * tree, reveal what the caret will be parked at, then land it. Both entry paths (undo/redo
- * swap, the consumer's `setSelection`) funnel through here, so the resolve/clamp/reveal rules
- * can't be carried by only one. A gap caret takes {@link restoreGapCaret}, the same road minus
- * the endpoint pair.
+ * The checks a stored selection passes before it goes back onto the live editor: each endpoint
+ * resolved against the current tree and clamped into its block. `caret-landing.ts :: restore` puts
+ * every stored selection back, a gap caret through {@link restoreGapCaret}.
  */
 import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
-import { applySelectionToDom } from './native-bridge';
+import { cellPoint } from './primitives';
 import { placeGapCaret } from './caret-doors';
 import { gapScopeChildren } from './gap-caret';
-import { tableCellCount } from './table-endpoint-snap';
-/**
- * Restore a snapshot. Never throws; an endpoint whose path no longer addresses a block is
- * declined before the reveal, so a dead snapshot cannot move the viewport or disturb a live
- * selection. What a decline does about the on-screen selection is the caller's policy.
- */
-export async function restoreSelection(selection, deps) {
-    const doc = deps.getDoc();
-    const anchor = resolveSelectionPoint(doc, selection.anchor);
-    const focus = resolveSelectionPoint(doc, selection.focus);
-    if (!anchor || !focus)
-        return 'unresolvable';
-    // Reveal exactly what the applier parks the caret at: a cell-coordinate focus parks in its
-    // deep [table, row, col] cell, and table rows window too.
-    const revealed = await deps.revealTarget(deps.selectionState.cellLandingFor(focus).path);
-    const placed = applySelectionToDom({ anchor, focus }, deps.selectionState, deps.getBlockElByPath);
-    return revealed && placed ? 'applied' : 'unplaced';
-}
-/**
- * Restore a gap caret. The scope check is `gapEligibleAt`'s, not a full eligibility gate:
- * the tree being restored is the one the gap was minted against, so `gapEdges` cannot have
- * changed under it, but the PATH can now name something no BlockList renders.
- */
+import { clampCellIndex, countsCells } from '../schema/block-kind-descriptor';
+/** Restores a gap caret with only the child-list check: the tree is the one the gap was made
+ *  against, so its `gapEdges` hold, but the path may name something no BlockList renders. */
 export async function restoreGapCaret(pos, deps) {
     const children = gapScopeChildren(deps.getDoc(), pos.parentPath);
     if (!children)
         return 'unresolvable';
+    deps.caretMemory.forget();
     const index = Math.min(Math.max(pos.index, 0), children.length);
     // The boundary itself mounts nothing; what must be on screen is the block it sits
     // against, so the gap's own BlockList is inside a live window when it renders.
     const neighbour = index < children.length ? index : index - 1;
-    const revealed = await deps.revealTarget([...pos.parentPath, neighbour]);
+    const neighbourPath = [...pos.parentPath, neighbour];
+    const mounted = (await deps.mount(neighbourPath)) !== null;
+    if (mounted)
+        await deps.reveal(neighbourPath);
     placeGapCaret(deps.selectionState, { parentPath: pos.parentPath, index });
-    return revealed ? 'applied' : 'unplaced';
+    return mounted ? 'applied' : 'unplaced';
 }
-/**
- * Clamp an endpoint into its block's addressable range, or null when its path no longer
- * resolves to a block (the document root included). The NODE KIND picks the coordinate space,
- * not the `cellCoordinate` flag: an intra-table endpoint is unflagged (see
- * {@link SelectionPoint}) yet still carries a cell index. The char-space bound is `raw`, which
- * on a marker-bearing kind runs past the content end; the DOM walk lands such an offset there.
- */
+/** Clamps an endpoint into its block's whole `raw`, markers included, or null when its path names
+ *  no block. An offset on a table path comes back flagged as a cell index, even a plain one. */
 export function resolveSelectionPoint(doc, point) {
     const node = nodeAt(doc, point.path);
     if (node === null || !isBlockNode(node))
         return null;
-    // Through the extent helper, not a local product: this ceiling and `cellEndpointDeepPath`'s
-    // bounds check must be the same number, or a clamped index is rejected by that check.
-    const limit = node.kind === 'table' ? tableCellCount(node) - 1 : node.raw.length;
-    const offset = Math.min(Math.max(point.offset, 0), Math.max(limit, 0));
+    const cells = countsCells(node);
+    const offset = cells
+        ? clampCellIndex(node, point.offset)
+        : Math.min(Math.max(point.offset, 0), node.raw.length);
     // Path copied so a restored endpoint never aliases the caller's snapshot.
-    return point.cellCoordinate
-        ? { path: point.path.slice(), offset, cellCoordinate: true }
+    return cells || point.cellCoordinate
+        ? cellPoint(point.path, offset)
         : { path: point.path.slice(), offset };
 }