@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/tree-operations/paste/dispatch.js

@@ -1,15 +1,15 @@
 /**
- * Single entry point for paste: parse the clipboard, pick inline vs structural, route
- * through the target's PasteSurface. Inline/structural surfaces are stateless transforms
- * this module applies; scoped-structural surfaces own their whole mutation including focus.
- * Cross-block paste (`undoEntry: 'join'`) uses DOM-level focus, because the originating
- * block's `pendingCursorOffset` may address a block the range delete is about to unmount.
+ * Single entry point for paste: parse the clipboard, pick inline or structural, and route through
+ * the target kind's `PasteSurface` (its paste handlers), whose inline and structural results this
+ * module applies; a scoped-structural handler owns its whole mutation, focus included. A
+ * cross-block paste focuses through the DOM, since its range delete may unmount the origin block.
  */
-import { parse } from '../../core/parser';
+import { readBlocks } from '../../core/parser';
 import { isBlockNode, nodeAt } from '../node-primitives';
-import { cutRangeFromDisplay } from '../node-ops';
-import { trailingLineEnding, trimTrailingLineEnding } from '../../core/lines';
-import { getPasteSurface } from '../paste-surfaces';
+import { docPathFrom } from '../../cursor/coordinate-spaces';
+import { replaceRangeInLeaf } from '../leaf-range';
+import { documentLineEnding, trailingLineEnding, trimTrailingLineEnding, withLineEnding } from '../../core/lines';
+import { getPasteSurface, isPasteSurfaceRegistered } from '../paste-surfaces';
 import { isReservedChromeChild } from '../../schema/reserved-chrome';
 import { applyInlineResult, applyStructuralResult } from './apply';
 import { normalizeClipboardForBody } from './body-write';
@@ -19,69 +19,84 @@ import { devWarn } from '../../dev-warn';
 import { applyListAbsorb, findListAbsorb } from './list-absorb';
 import { applyListBreakOut, findListBreakOut } from './list-break-out';
 import { applyPasteTransforms } from './paste-transforms';
+import { inlineResultInEnding } from './line-ending';
 import { contentBlocks, pickPasteStrategy } from './strategy';
+import { childSlotAt } from '../list/task-paragraph';
+import { storedAsAt } from '../stored-as';
 /** Execute a paste at the specified target position. */
 export async function pasteDispatch(input, ctx) {
     if (!input.pastedText)
         return {};
     // Once, before any branch below reads the text; a transform that empties it is an
     // empty paste.
-    const transformed = applyPasteTransforms(input.pastedText, ctx.activePlugins);
+    const { activePlugins } = ctx;
+    const { reading } = ctx;
+    // The hooks read the LF text; every line the paste writes takes the document's own ending.
+    const ending = documentLineEnding(ctx.doc);
+    const transformed = applyPasteTransforms(input.pastedText, activePlugins);
     if (!transformed)
         return {};
     // Ahead of the fragment parse, so the strategy pick and every landed kind follow the
     // bytes a bodyWrite-declaring ancestor will actually accept.
     const pastedText = normalizeClipboardForBody(ctx.doc, input.targetPath, transformed);
-    const parsed = parse(pastedText, { grammar: ctx.grammar, scope: 'fragment' });
-    if (parsed.children.length === 0)
-        return {};
     const targetNode = nodeAt(ctx.doc, input.targetPath);
     if (!targetNode)
         return {};
-    // A reserved-chrome leaf is single-line by serialization, so paste there is forced inline
-    // ahead of the container-paste family: a multi-block clipboard must never split it. The trim
-    // drops the edge spaces the newline flattening minted, not bytes anyone copied.
+    // Undo's caret for every commit below but a scoped-structural surface's own: where the paste
+    // began, never where it lands.
+    const start = {
+        path: docPathFrom(input.targetPath),
+        offset: input.caretBefore ?? input.preDelete?.start ?? input.offset
+    };
+    const store = storedAsAt(ctx.doc, input.targetPath, reading);
+    const parsed = readBlocks(withLineEnding(pastedText, ending), {
+        grammar: reading.grammar,
+        scope: 'fragment'
+    });
+    if (parsed.children.length === 0)
+        return {};
+    // A reserved title child serializes on one line, so paste there is forced inline before any
+    // container route could split it; the trim drops only the spaces the flattening made.
     const chromeParent = nodeAt(ctx.doc, input.targetPath.slice(0, -1));
     if (chromeParent &&
         isBlockNode(chromeParent) &&
         isReservedChromeChild(chromeParent, input.targetPath[input.targetPath.length - 1])) {
         const flattened = pastedText.replace(/(\r?\n)+/g, ' ').trim();
-        const hook = getPasteSurface(targetNode.kind)?.onInlinePaste ?? defaultInlineHook;
-        const result = hook(targetNode, input.offset, flattened, input.preDelete, ctx.seam);
-        const landing = await applyInlineResult(input.targetPath, result, ctx);
+        const hook = getPasteSurface(targetNode.kind, activePlugins)?.onInlinePaste ?? defaultInlineHook;
+        const result = hook(targetNode, input.offset, flattened, input.preDelete, store, ending);
+        const landing = await applyInlineResult(input.targetPath, result, ctx, start);
         return inlineCaretResult(result.caretOffset, landing);
     }
-    // The delete half the container routes never ran, spent ONCE and ahead of the strategy pick:
-    // each finder decides on the TARGET's bytes, and a range still standing there answers about
-    // bytes the paste is removing. The hook routes cut their own, kind rules included.
-    const target = targetAfterPreDelete(targetNode, input, ctx.seam);
-    const unwrap = findContainerMatchingUnwrap(ctx.doc, input.targetPath, target.offset, parsed, ctx.undoEntry === 'join', target.raw);
+    // The delete half, applied before the container finders, which decide on the target's bytes and
+    // never cut the range themselves; the hook routes cut their own, kind rules included.
+    const target = targetAfterPreDelete(targetNode, input, store, ending);
+    const unwrap = findContainerMatchingUnwrap(ctx.doc, input.targetPath, target.offset, parsed, ctx.crossBlock === true, target.raw);
     if (unwrap) {
-        await applyContainerMatchingPaste(unwrap, ctx);
+        await applyContainerMatchingPaste(unwrap, ctx, start);
         return {};
     }
-    // The rest of the container paste-merge family, for single-block non-empty targets:
-    // absorb when `matchesAncestor` accepts the enclosing container, break-out when it
-    // does not.
+    // For a single-block non-empty target: absorb when `matchesAncestor` accepts the enclosing
+    // container, break out when it does not.
     const absorb = findListAbsorb(ctx.doc, input.targetPath, parsed, target.offset, target.raw);
     if (absorb) {
-        await applyListAbsorb(absorb, parsed.children[0], ctx);
+        await applyListAbsorb(absorb, parsed.children[0], ctx, start);
         return {};
     }
     const breakOut = findListBreakOut(ctx.doc, input.targetPath, parsed, target.offset, target.raw);
     if (breakOut) {
-        await applyListBreakOut(breakOut, parsed.children, ctx);
+        await applyListBreakOut(breakOut, parsed.children, ctx, start);
         return {};
     }
-    const surface = getPasteSurface(targetNode.kind);
-    if (surface === undefined) {
+    const surface = getPasteSurface(targetNode.kind, activePlugins);
+    // A plugin's surface this editor left out is no gap to warn about: the default hooks are meant.
+    if (surface === undefined && !isPasteSurfaceRegistered(targetNode.kind)) {
         devWarn('paste-dispatch', 'no paste surface registered for this kind; falling through to default hooks. Register ' +
             'via registerPasteSurface() if the kind has its own paste semantics', targetNode.kind);
     }
     const blocks = surface?.blankEdgesArePackaging ? contentBlocks(parsed.children) : parsed.children;
     const clipboardStrategy = pickPasteStrategy(blocks);
-    // A surface omitting both structural hooks (code blocks) forces paste inline, so its
-    // markdown stays verbatim.
+    // A kind whose paste handlers omit both structural hooks (code blocks) forces paste inline,
+    // so its markdown stays verbatim.
     const surfaceForcesInline = surface !== undefined &&
         surface.onStructuralPaste === undefined &&
         surface.onScopedStructuralPaste === undefined;
@@ -91,49 +106,49 @@ export async function pasteDispatch(input, ctx) {
             doc: ctx.doc,
             targetPath: input.targetPath,
             blocks: blocks.slice(),
-            controller: ctx.controller,
-            undoEntry: ctx.undoEntry ?? 'own',
-            grammar: ctx.grammar
+            controller: ctx.controller
         });
         return {};
     }
     if (strategy === 'inline') {
         const hook = surface?.onInlinePaste ?? defaultInlineHook;
-        const result = hook(targetNode, input.offset, pastedText, input.preDelete, ctx.seam);
-        const landing = await applyInlineResult(input.targetPath, result, ctx);
+        const result = inlineResultInEnding(targetNode.raw, hook(targetNode, input.offset, pastedText, input.preDelete, store, ending), ending);
+        const landing = await applyInlineResult(input.targetPath, result, ctx, start);
         return inlineCaretResult(result.caretOffset, landing);
     }
     const hook = surface?.onStructuralPaste ?? defaultStructuralHook;
-    const result = hook(targetNode, input.offset, blocks.slice(), input.preDelete, ctx.seam);
-    await applyStructuralResult(input.targetPath, result, ctx, trailingSeparatorOf(parsed, result, surface));
+    const slot = childSlotAt(ctx.doc, input.targetPath);
+    const result = hook(targetNode, input.offset, blocks.slice(), input.preDelete, store, ending, slot);
+    await applyStructuralResult(input.targetPath, result, ctx, start, trailingSeparatorOf(parsed, result, surface));
     return {};
 }
-/** The target's bytes and caret as the paste's delete half leaves them. */
-function targetAfterPreDelete(node, input, seam) {
+/** The target's bytes and caret as the paste's delete half leaves them: what a Delete over the range
+ *  writes, since the container routes put their blocks after it. */
+function targetAfterPreDelete(node, input, store, lineEnding) {
     if (!input.preDelete)
         return { raw: node.raw, offset: input.offset };
-    const cut = cutRangeFromDisplay(node, trimTrailingLineEnding(node.raw), input.preDelete, seam?.presentationMode, seam?.linkRef);
-    return { raw: cut.display + trailingLineEnding(node.raw), offset: cut.offset };
+    const cut = replaceRangeInLeaf(node, input.preDelete, '', store);
+    return {
+        raw: trimTrailingLineEnding(cut.raw) + trailingLineEnding(node.raw, lineEnding),
+        offset: cut.caret
+    };
 }
 /**
- * A clipboard's trailing blank line is CONTENT: a parse folds exactly one into `suffix`
- * while a second already materializes as a block, and the inline route splices the bytes verbatim
- * — so consuming children alone made one route keep the copied separation and its twin lose it.
- * Spent only where the splice leaves nothing behind the pasted blocks; a residue or a follower
- * already carries a separator of its own, and a packaging surface declines the whole question.
+ * The clipboard's trailing blank line (`suffix`), which the inline route pastes verbatim too;
+ * landed only where no residue follows the pasted blocks and the kind keeps blank edges.
  */
 function trailingSeparatorOf(parsed, result, surface) {
     if (surface?.blankEdgesArePackaging)
         return '';
-    // `focusReplacementIndex` IS the last pasted node (`paste/focus-target.ts`), so anything past
+    // `focusReplacementIndex` is the last pasted node (`paste/focus-target.ts`), so anything past
     // it is reattached residue.
     return result.focusReplacementIndex === result.replacement.length - 1 ? parsed.suffix : '';
 }
-/** The hook's own caret offset, overridden by the settled landing where a fold moved it. */
+/** The hook's own caret offset, overridden by where the caret ended up when a merge moved it. */
 function inlineCaretResult(caretOffset, landing) {
     if (!landing)
         return { inlineCaretOffset: caretOffset };
     return { inlineCaretOffset: landing.offset, inlineCaretPath: landing.path };
 }
 export { pickPasteStrategy } from './strategy';
-export { defaultInlineHook, defaultStructuralHook, __getDefaultTextSurface } from './hooks';
+export { defaultInlineHook, defaultStructuralHook } from './hooks';

package/dist/tree-operations/paste/focus-target.d.ts

@@ -1,27 +1,24 @@
 /**
- * The caret a `[prefix?, ...pasted, residue?]` replacement lands, on both sides of the splice
- * settle: which node the door aims at, the position the settle's folds carry for it, and the
- * offset that position is landable at.
+ * The caret a `[prefix?, ...pasted, residue?]` replacement lands, on both sides of the separator
+ * fix-up: which node the paste aims at, the position the fix-up's merges keep updated for it,
+ * and the leaf and offset the caret can actually sit at there.
  */
 import type { CstNode } from '../../core/nodes';
 import type { NodeView } from '../../core/node-views';
 import type { TrackedPosition } from '../settle';
+import { type LeafPosition } from '../container-offsets';
 /**
- * Focus index for the replacement: the last PASTED node. Single-sourced so every structural
- * route skips the reattached residue identically. Applies only where the residue is a SEPARATE
- * node; a route that reattaches it inside the last pasted leaf lands at a char offset in a
- * different coordinate space.
+ * The last pasted node's index, shared so every structural route skips a residue node the same
+ * way; a residue reattached inside the last pasted leaf is not a node and isn't counted.
  */
 export declare function focusIndexBeforeResidue(replacementLength: number, hasResidue: boolean): number;
 /**
- * The position the splice settle must carry: the end of the pasted bytes, in the scope's slots.
- * `CURSOR_END` resolves to the node's own display end here — a sentinel handed to the tracker
- * would clamp to whatever the fold reattached behind it, which is the bug it exists to prevent.
+ * The end of the pasted bytes, for the fix-up's merges to keep updated. `CURSOR_END` resolves to
+ * the node's display end here, or the tracker would clamp it past whatever a merge reattached.
  */
 export declare function trackedPasteCaret(replacement: readonly CstNode[], at: number, focusIndex: number, focusOffset: number): TrackedPosition;
 /**
- * The offset {@link trackedPasteCaret}'s settled position is landable at. Only a known leaf spends
- * the tracked byte: a container walks any numeric offset to its last child, so its raw offsets
- * address no caret seat. Anything the caller named itself stands as given.
+ * The leaf and offset holding the tracked byte inside the landed block. An offset the caller named
+ * stands as given, and a block whose bytes map to no leaf (a table) takes the caret at its end.
  */
-export declare function landedPasteOffset(landed: NodeView | undefined, tracked: TrackedPosition, focusOffset: number): number;
+export declare function landedPastePosition(landed: NodeView | undefined, tracked: TrackedPosition, focusOffset: number): LeafPosition;

package/dist/tree-operations/paste/focus-target.js

@@ -1,24 +1,21 @@
 /**
- * The caret a `[prefix?, ...pasted, residue?]` replacement lands, on both sides of the splice
- * settle: which node the door aims at, the position the settle's folds carry for it, and the
- * offset that position is landable at.
+ * The caret a `[prefix?, ...pasted, residue?]` replacement lands, on both sides of the separator
+ * fix-up: which node the paste aims at, the position the fix-up's merges keep updated for it,
+ * and the leaf and offset the caret can actually sit at there.
  */
 import { CURSOR_END } from '../../block-component';
 import { trimTrailingLineEnding } from '../../core/lines';
-import { tryGetBlockKindDescriptor } from '../../schema/block-kind-descriptor';
+import { leafAtRawOffset } from '../container-offsets';
 /**
- * Focus index for the replacement: the last PASTED node. Single-sourced so every structural
- * route skips the reattached residue identically. Applies only where the residue is a SEPARATE
- * node; a route that reattaches it inside the last pasted leaf lands at a char offset in a
- * different coordinate space.
+ * The last pasted node's index, shared so every structural route skips a residue node the same
+ * way; a residue reattached inside the last pasted leaf is not a node and isn't counted.
  */
 export function focusIndexBeforeResidue(replacementLength, hasResidue) {
     return hasResidue && replacementLength >= 2 ? replacementLength - 2 : replacementLength - 1;
 }
 /**
- * The position the splice settle must carry: the end of the pasted bytes, in the scope's slots.
- * `CURSOR_END` resolves to the node's own display end here — a sentinel handed to the tracker
- * would clamp to whatever the fold reattached behind it, which is the bug it exists to prevent.
+ * The end of the pasted bytes, for the fix-up's merges to keep updated. `CURSOR_END` resolves to
+ * the node's display end here, or the tracker would clamp it past whatever a merge reattached.
  */
 export function trackedPasteCaret(replacement, at, focusIndex, focusOffset) {
     const displayEnd = trimTrailingLineEnding(replacement[focusIndex]?.raw ?? '').length;
@@ -28,13 +25,11 @@ export function trackedPasteCaret(replacement, at, focusIndex, focusOffset) {
     };
 }
 /**
- * The offset {@link trackedPasteCaret}'s settled position is landable at. Only a known leaf spends
- * the tracked byte: a container walks any numeric offset to its last child, so its raw offsets
- * address no caret seat. Anything the caller named itself stands as given.
+ * The leaf and offset holding the tracked byte inside the landed block. An offset the caller named
+ * stands as given, and a block whose bytes map to no leaf (a table) takes the caret at its end.
  */
-export function landedPasteOffset(landed, tracked, focusOffset) {
+export function landedPastePosition(landed, tracked, focusOffset) {
     if (focusOffset !== CURSOR_END)
-        return focusOffset;
-    const leaf = landed && tryGetBlockKindDescriptor(landed.kind)?.isContainer === false;
-    return leaf ? tracked.offset : CURSOR_END;
+        return { path: [], offset: focusOffset };
+    return (landed && leafAtRawOffset(landed, tracked.offset)) ?? { path: [], offset: CURSOR_END };
 }

package/dist/tree-operations/paste/hooks.d.ts

@@ -3,15 +3,10 @@
  * for every built-in kind whose descriptor advertises `supportsInline`.
  */
 import { type CstNode } from '../../core/nodes';
-import { type PasteSurface, type PasteRange, type PasteSeam, type InlinePasteResult, type StructuralPasteResult } from '../paste-surfaces';
-export declare function defaultInlineHook(node: CstNode, offset: number, text: string, preDelete?: PasteRange, seam?: PasteSeam): InlinePasteResult;
-export declare function defaultStructuralHook(node: CstNode, offset: number, blocks: CstNode[], preDelete?: PasteRange, seam?: PasteSeam): StructuralPasteResult;
-/**
- * Caret target for a structural paste: the end of the PASTED content, not the trailing
- * residue. A mid-block caret leaves the post-caret slice as the replacement's last node,
- * so the pasted content ends one node earlier. Takes the display and offset the delete half
- * already resolved — a seam cleanup moves both, and re-deriving them here would disagree.
- */
-export declare function pastedContentFocusIndex(display: string, offset: number, replacementLength: number): number;
-/** Test-only: produce a default text surface descriptor. */
-export declare function __getDefaultTextSurface(kind: PasteSurface['kind']): PasteSurface;
+import { type LineEnding } from '../../core/lines';
+import type { ChildSlot } from '../list/task-paragraph';
+import { type PasteRange, type InlinePasteResult, type StructuralPasteResult } from '../paste-surfaces';
+import type { StoredAs } from '../../schema/stored-as';
+/** The pasted text over the selection, or at the caret, written as typing it there would be. */
+export declare function defaultInlineHook(node: CstNode, offset: number, text: string, preDelete: PasteRange | undefined, store: StoredAs, lineEnding: LineEnding): InlinePasteResult;
+export declare function defaultStructuralHook(node: CstNode, offset: number, blocks: CstNode[], preDelete: PasteRange | undefined, store: StoredAs, lineEnding: LineEnding, slot: ChildSlot): StructuralPasteResult;

package/dist/tree-operations/paste/hooks.js

@@ -6,54 +6,65 @@ import { CURSOR_END } from '../../block-component';
 import { isBuiltinBlockKind } from '../../core/nodes';
 import { trailingLineEnding, trimTrailingLineEnding } from '../../core/lines';
 import { buildPastedReplacement } from './paste-replacement';
-import { cutRangeFromDisplay } from '../node-ops';
-import { focusIndexBeforeResidue } from './focus-target';
+import { replaceRangeInLeaf } from '../leaf-range';
+import { getContentRange, readInline } from '../../core/inline';
+import { CONTENT_VISIBILITY, visibleRuns } from '../../core/inline/visibility';
 import { getAllRegisteredKinds, tryGetBlockKindDescriptor } from '../../schema/block-kind-descriptor';
 import { registerPasteSurface } from '../paste-surfaces';
 // Registered by their own component instead of the loop below. One registrar per kind, so
 // correctness doesn't hinge on module load order.
 const BESPOKE_SURFACE_KINDS = new Set(['tableCell']);
-/**
- * The leaf's bytes and caret after the paste's DELETE half — through the one join seam, so a cut
- * that stranded a delimiter run the reader never saw drops it here rather than pasting it into
- * view (live-mode.md § 4.5). The range is forwarded whole: the endpoints are the seam's to read.
- */
-function applyPreDelete(node, display, preDelete, offset, seam) {
-    if (!preDelete)
-        return { display, offset };
-    return cutRangeFromDisplay(node, display, preDelete, seam?.presentationMode, seam?.linkRef);
-}
-export function defaultInlineHook(node, offset, text, preDelete, seam) {
-    const display = trimTrailingLineEnding(node.raw);
-    const lineEnding = trailingLineEnding(node.raw);
-    const { display: effectiveDisplay, offset: effectiveOffset } = applyPreDelete(node, display, preDelete, offset, seam);
-    const newDisplay = effectiveDisplay.slice(0, effectiveOffset) + text + effectiveDisplay.slice(effectiveOffset);
-    return {
-        newRaw: newDisplay + lineEnding,
-        caretOffset: effectiveOffset + text.length
-    };
-}
-export function defaultStructuralHook(node, offset, blocks, preDelete, seam) {
-    const display = trimTrailingLineEnding(node.raw);
-    const cut = applyPreDelete(node, display, preDelete, offset, seam);
-    // Compare the BYTES rather than the range: a cleanup can drop more than the selection did,
-    // and an empty range leaves them equal, which is exactly when the original node stands.
-    const synthLeaf = cut.display === display ? node : { ...node, raw: cut.display + trailingLineEnding(node.raw) };
-    const replacement = buildPastedReplacement(synthLeaf, cut.offset, blocks);
+/** The pasted text over the selection, or at the caret, written as typing it there would be. */
+export function defaultInlineHook(node, offset, text, preDelete, store, lineEnding) {
+    const range = preDelete ?? { start: offset, end: offset };
+    const bare = dropClosingLineEnding(text);
+    const probe = replaceRangeInLeaf(node, range, bare, store);
+    const edit = bare === text || endsVisibleLine(node, probe, store)
+        ? probe
+        : replaceRangeInLeaf(node, range, text, store);
     return {
-        replacement,
-        focusReplacementIndex: pastedContentFocusIndex(cut.display, cut.offset, replacement.length),
-        focusOffset: CURSOR_END
+        newRaw: trimTrailingLineEnding(edit.raw) + trailingLineEnding(node.raw, lineEnding),
+        caretOffset: edit.caret
     };
 }
 /**
- * Caret target for a structural paste: the end of the PASTED content, not the trailing
- * residue. A mid-block caret leaves the post-caret slice as the replacement's last node,
- * so the pasted content ends one node earlier. Takes the display and offset the delete half
- * already resolved — a seam cleanup moves both, and re-deriving them here would disagree.
+ * `text` without the ending of its last line, which against a line end would leave a blank line
+ * in the paragraph; a whole blank last line stays, since the clipboard carried it as a block.
  */
-export function pastedContentFocusIndex(display, offset, replacementLength) {
-    return focusIndexBeforeResidue(replacementLength, offset < display.length);
+function dropClosingLineEnding(text) {
+    const closing = /\r?\n$/.exec(text);
+    if (!closing)
+        return text;
+    const rest = text.slice(0, closing.index);
+    return rest === '' || /\r?\n$/.test(rest) ? text : rest;
+}
+/** Whether nothing the user sees follows the caret on its line: a delimiter run the reading
+ *  hides there, such as a bold word's closer, still ends the line. */
+function endsVisibleLine(node, edit, store) {
+    const after = trimTrailingLineEnding(edit.raw).slice(edit.caret);
+    if (after === '' || /^\r?\n/.test(after))
+        return true;
+    if (!store.reading.hidesDelimitersAtCaret())
+        return false;
+    const lineEnd = edit.caret + (/\r?\n/.exec(after)?.index ?? after.length);
+    const content = getContentRange({ ...node, raw: edit.raw });
+    const { resolver, grammar } = store.reading;
+    const inlines = readInline(edit.raw, content.start, content.end, resolver, grammar);
+    return !visibleRuns(inlines, edit.raw, CONTENT_VISIBILITY, { grammar }).some((run) => run.visible && run.text !== '' && run.end > edit.caret && run.start < lineEnd);
+}
+export function defaultStructuralHook(node, offset, blocks, preDelete, store, lineEnding, slot) {
+    // The blocks go in after the cut, as a split does, so the cut takes no text of its own.
+    const cut = preDelete && replaceRangeInLeaf(node, preDelete, '', store);
+    const display = cut && trimTrailingLineEnding(cut.raw);
+    // Compare the bytes rather than the range: a cleanup can drop more than the selection did,
+    // and an empty range leaves them equal, which is exactly when the original node stands.
+    const synthLeaf = !cut || display === trimTrailingLineEnding(node.raw)
+        ? node
+        : { ...node, raw: display + trailingLineEnding(node.raw, lineEnding) };
+    const { nodes, lastPastedIndex } = buildPastedReplacement(synthLeaf, cut ? cut.caret : offset, blocks, lineEnding, store.reading.grammar, slot);
+    // The caret lands where the pasted bytes end, which the fix-up tracks when it merges the
+    // residue into the last pasted block.
+    return { replacement: nodes, focusReplacementIndex: lastPastedIndex, focusOffset: CURSOR_END };
 }
 // Built-in kinds are all registered by the time this top level runs; a plugin kind
 // registering later must register its own paste surface.
@@ -70,11 +81,3 @@ for (const kind of getAllRegisteredKinds()) {
         });
     }
 }
-/** Test-only: produce a default text surface descriptor. */
-export function __getDefaultTextSurface(kind) {
-    return {
-        kind,
-        onInlinePaste: defaultInlineHook,
-        onStructuralPaste: defaultStructuralHook
-    };
-}

package/dist/tree-operations/paste/line-ending.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The pasted line breaks written in the document's own ending. The clipboard reaches the paste
+ * transforms and hooks as LF, so an inline hook's result is rewritten here on its way in.
+ */
+import type { LineEnding } from '../../core/lines';
+import type { InlinePasteResult } from '../paste-surfaces';
+/**
+ * An inline hook's result with the breaks it spliced in written as `ending`; only the bytes
+ * between the unchanged head and tail are the paste's, so the block's own endings stay.
+ */
+export declare function inlineResultInEnding(before: string, result: InlinePasteResult, ending: LineEnding): InlinePasteResult;

package/dist/tree-operations/paste/line-ending.js

@@ -0,0 +1,32 @@
+/**
+ * The pasted line breaks written in the document's own ending. The clipboard reaches the paste
+ * transforms and hooks as LF, so an inline hook's result is rewritten here on its way in.
+ */
+/**
+ * An inline hook's result with the breaks it spliced in written as `ending`; only the bytes
+ * between the unchanged head and tail are the paste's, so the block's own endings stay.
+ */
+export function inlineResultInEnding(before, result, ending) {
+    if (ending === '\n')
+        return result;
+    const after = result.newRaw;
+    let head = 0;
+    while (head < before.length && before[head] === after[head])
+        head++;
+    let tail = 0;
+    while (tail < before.length - head &&
+        tail < after.length - head &&
+        before[before.length - 1 - tail] === after[after.length - 1 - tail]) {
+        tail++;
+    }
+    const end = after.length - tail;
+    let lengthened = 0;
+    const newRaw = after.replace(/(?<!\r)\n/g, (lf, at) => {
+        if (at < head || at >= end)
+            return lf;
+        if (at < result.caretOffset)
+            lengthened++;
+        return ending;
+    });
+    return { newRaw, caretOffset: result.caretOffset + lengthened };
+}

package/dist/tree-operations/paste/list-absorb.d.ts

@@ -1,29 +1,26 @@
 /**
- * Paste absorb: a same-type list pasted into a non-empty list item flattens as siblings of
- * the target, with markers normalized to the enclosing list's style — the flat result most
- * markdown editors produce. Covers the single-block non-empty same-type case that runs
- * after `findContainerMatchingUnwrap` and would otherwise fall through to the default
- * structural paste; mismatched types go to `list-break-out` instead.
+ * Paste absorb: a same-type list pasted into a non-empty list item lands as siblings of the target
+ * item, markers restyled to the enclosing list's, as most markdown editors do. Runs after
+ * `findContainerMatchingUnwrap`; a mismatched type goes to `list-break-out` instead.
  */
 import type { CstNode, Document } from '../../core/nodes';
 import type { PasteDispatchContext } from './dispatch';
+import type { CommitSnapshotArg } from '../../action-contracts';
 export interface ListAbsorb {
     listPath: number[];
     itemIndex: number;
     innerIndex: number;
     offset: number;
-    /** The target leaf's bytes AFTER the paste's delete half. */
+    /** The target leaf's bytes after the paste's delete half. */
     targetRaw?: string;
 }
 /**
- * The absorb plan, or null when any precondition fails: a single top block declaring
- * `containerPaste.siblingAbsorb`, whose `matchesAncestor` accepts the nearest list
- * ancestor, targeting a direct leaf of the listItem. Mismatched types fall through to
- * `findListBreakOut`.
+ * The absorb plan when a single top block declaring `containerPaste.siblingAbsorb` matches the
+ * nearest list and the target is a direct leaf of its item; null otherwise.
  */
 export declare function findListAbsorb(doc: Document, targetPath: number[], parsed: Document, offset: number, targetRaw?: string): ListAbsorb | null;
 /**
  * Split the target item at the caret, splice the pasted items between the halves,
  * normalize markers, renumber. One undo entry on the list's scope.
  */
-export declare function applyListAbsorb(plan: ListAbsorb, pastedList: CstNode, ctx: PasteDispatchContext): Promise<void>;
+export declare function applyListAbsorb(plan: ListAbsorb, pastedList: CstNode, ctx: PasteDispatchContext, start: CommitSnapshotArg): Promise<void>;

package/dist/tree-operations/paste/list-absorb.js

@@ -1,28 +1,25 @@
 /**
- * Paste absorb: a same-type list pasted into a non-empty list item flattens as siblings of
- * the target, with markers normalized to the enclosing list's style — the flat result most
- * markdown editors produce. Covers the single-block non-empty same-type case that runs
- * after `findContainerMatchingUnwrap` and would otherwise fall through to the default
- * structural paste; mismatched types go to `list-break-out` instead.
+ * Paste absorb: a same-type list pasted into a non-empty list item lands as siblings of the target
+ * item, markers restyled to the enclosing list's, as most markdown editors do. Runs after
+ * `findContainerMatchingUnwrap`; a mismatched type goes to `list-break-out` instead.
  */
 import { CURSOR_END } from '../../block-component';
 import { metadataOf } from '../../core/nodes';
+import { documentLineEnding } from '../../core/lines';
 import { nodeAt, ensureEditableContainers } from '../node-primitives';
 import { cloneNode } from '../clone';
 import { containerPasteFor } from './container-paste';
 import { stampStructuralChange } from '../structural-change';
 import { renumberOrderedList, templatePastedItemMarkers } from '../list/ordered-markers';
-import { spliceTerminatedItems } from '../list/terminator';
+import { spliceMany } from '../splice-many';
 import { containerScopeState } from './parent-scope';
 import { buildSplitItems } from '../list/list-builders';
 import { findEnclosingListForPaste } from './find-enclosing-list';
 import { focusIndexBeforeResidue } from './focus-target';
 import { docPathFrom } from '../../cursor/coordinate-spaces';
 /**
- * The absorb plan, or null when any precondition fails: a single top block declaring
- * `containerPaste.siblingAbsorb`, whose `matchesAncestor` accepts the nearest list
- * ancestor, targeting a direct leaf of the listItem. Mismatched types fall through to
- * `findListBreakOut`.
+ * The absorb plan when a single top block declaring `containerPaste.siblingAbsorb` matches the
+ * nearest list and the target is a direct leaf of its item; null otherwise.
  */
 export function findListAbsorb(doc, targetPath, parsed, offset, targetRaw) {
     if (parsed.children.length !== 1)
@@ -48,7 +45,7 @@ export function findListAbsorb(doc, targetPath, parsed, offset, targetRaw) {
  * Split the target item at the caret, splice the pasted items between the halves,
  * normalize markers, renumber. One undo entry on the list's scope.
  */
-export async function applyListAbsorb(plan, pastedList, ctx) {
+export async function applyListAbsorb(plan, pastedList, ctx, start) {
     const outer = nodeAt(ctx.doc, plan.listPath);
     if (!outer?.children)
         return;
@@ -58,7 +55,8 @@ export async function applyListAbsorb(plan, pastedList, ctx) {
         return;
     if (!item.children[plan.innerIndex])
         return;
-    const { leadingItem, trailingItem } = buildSplitItems(item, plan.innerIndex, plan.offset, plan.targetRaw);
+    const lineEnding = documentLineEnding(ctx.doc);
+    const { leadingItem, trailingItem } = buildSplitItems(item, plan.innerIndex, plan.offset, lineEnding, plan.targetRaw, ctx.reading.grammar);
     const pastedItems = (pastedList.children ?? []).map((c) => cloneNode(c));
     const replacement = [];
     if (leadingItem)
@@ -68,16 +66,16 @@ export async function applyListAbsorb(plan, pastedList, ctx) {
     if (trailingItem)
         replacement.push(trailingItem);
     for (const node of replacement)
-        ensureEditableContainers(node);
+        ensureEditableContainers(node, lineEnding);
     const outerOrdered = metadataOf(outer, 'list')?.ordered ?? false;
     templatePastedItemMarkers(replacement, outer, plan.itemIndex);
     await ctx.controller.commitMultiScope({
         scopes: [{ node: outer, state: outerState, path: plan.listPath }],
-        snapshot: ctx.undoEntry === 'join' ? 'skip' : { path: docPathFrom(plan.listPath), offset: 0 },
+        snapshot: start,
         mutate: ([scopeView]) => {
             const sharing = scopeView.sharing;
-            spliceTerminatedItems(scopeView.children, plan.itemIndex, 1, replacement);
-            // Only items AFTER the replacement region: their proxies already exist, so marker
+            spliceMany(scopeView.children, plan.itemIndex, 1, replacement);
+            // Only items after the replacement region: their proxies already exist, so marker
             // mutations propagate to the DOM.
             const afterReplacementIdx = plan.itemIndex + replacement.length;
             if (outerOrdered && afterReplacementIdx < scopeView.children.length) {
@@ -97,10 +95,10 @@ export async function applyListAbsorb(plan, pastedList, ctx) {
             detail: { source: 'list-absorb', listPath: plan.listPath },
             eventPath: docPathFrom(plan.listPath)
         },
-        afterTick: () => {
-            // The shared structural-paste landing rule: last pasted item, before the residue.
+        landing: () => {
+            // The shared structural-paste caret rule: last pasted item, before the residue.
             const lastPastedIdx = plan.itemIndex + focusIndexBeforeResidue(replacement.length, trailingItem !== null);
-            return ctx.controller.landCaret([...plan.listPath, lastPastedIdx], CURSOR_END);
+            return { path: docPathFrom([...plan.listPath, lastPastedIdx]), offset: CURSOR_END };
         }
     });
 }