@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/tree-operations/paste/list-break-out.d.ts

@@ -1,10 +1,13 @@
 /**
  * Paste break-out: lift a pasted list out of an enclosing list rather than nesting it,
- * whenever the two ordered flags disagree — keeping the pasted list separate preserves its
+ * whenever the two ordered flags disagree: keeping the pasted list separate preserves its
  * semantic type. Same-type pastes go through `list-absorb`.
  */
 import type { CstNode, Document } from '../../core/nodes';
+import { type LineEnding } from '../../core/lines';
 import type { PasteDispatchContext } from './dispatch';
+import type { CommitSnapshotArg } from '../../action-contracts';
+import type { GrammarView } from '../../schema/block-openers';
 export interface ListBreakOut {
     /** Path to the nearest enclosing list ancestor. */
     listPath: number[];
@@ -14,29 +17,27 @@ export interface ListBreakOut {
     innerIndex: number;
     /** Caret offset within the target leaf's raw. */
     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 break-out plan, or null: requires a top block declaring `containerPaste.siblingAbsorb`
- * whose `matchesAncestor` REJECTS the nearest list ancestor (matching pastes belong to
- * `list-absorb` and must not also trigger here), targeting a direct leaf of the listItem.
+ * The break-out plan when a top block declaring `containerPaste.siblingAbsorb` does not match the
+ * nearest list and the target is a direct leaf of its item; null otherwise.
  */
 export declare function findListBreakOut(doc: Document, targetPath: number[], parsed: Document, offset: number, targetRaw?: string): ListBreakOut | null;
 /**
  * Split the enclosing list at the target item and splice the pasted blocks between the
  * halves at the list's parent level, in one multi-scope entry.
  */
-export declare function applyListBreakOut(plan: ListBreakOut, pastedBlocks: CstNode[], ctx: PasteDispatchContext): Promise<void>;
+export declare function applyListBreakOut(plan: ListBreakOut, pastedBlocks: CstNode[], ctx: PasteDispatchContext, start: CommitSnapshotArg): Promise<void>;
 export interface ListBreakOutReplacement {
-    /** `[firstHalfList?, ...pastedBlocks, secondHalfList?]` — halves omitted when empty. */
+    /** `[firstHalfList?, ...pastedBlocks, secondHalfList?]`, halves omitted when empty. */
     replacement: CstNode[];
     /** The second-half list (post-caret residue) is present as the last node. */
     hasTrailingResidue: boolean;
 }
 /**
- * Split `list` at `(itemIndex, innerIndex, offset)` and splice `pastedBlocks` between the
- * halves. `hasTrailingResidue` lets the caller land the caret on the last pasted block
- * rather than the residue. Input nodes are cloned, not mutated.
+ * Split `list` at `(itemIndex, innerIndex, offset)` and splice `pastedBlocks` between the halves,
+ * cloning every input node rather than mutating it.
  */
-export declare function buildListBreakOutReplacement(list: CstNode, itemIndex: number, innerIndex: number, offset: number, pastedBlocks: CstNode[], targetRaw?: string): ListBreakOutReplacement;
+export declare function buildListBreakOutReplacement(list: CstNode, itemIndex: number, innerIndex: number, offset: number, pastedBlocks: CstNode[], ending: LineEnding, targetRaw: string | undefined, grammar: GrammarView): ListBreakOutReplacement;

package/dist/tree-operations/paste/list-break-out.js

@@ -1,6 +1,6 @@
 /**
  * Paste break-out: lift a pasted list out of an enclosing list rather than nesting it,
- * whenever the two ordered flags disagree — keeping the pasted list separate preserves its
+ * whenever the two ordered flags disagree: keeping the pasted list separate preserves its
  * semantic type. Same-type pastes go through `list-absorb`.
  */
 import { CURSOR_END } from '../../block-component';
@@ -9,19 +9,16 @@ import { cloneNode } from '../clone';
 import { spliceMany } from '../splice-many';
 import { stampStructuralChange } from '../structural-change';
 import { containerPasteFor } from './container-paste';
-import { rebuildListRaw } from '../../schema/container-rebuilders';
-import { newlineTerminateListItems } from '../list/terminator';
-import { trailingLineEnding } from '../../core/lines';
+import { documentLineEnding } from '../../core/lines';
 import { assembleListHalf, buildSplitItems } from '../list/list-builders';
 import { orderedBaseOf } from '../list/ordered-markers';
 import { findEnclosingListForPaste } from './find-enclosing-list';
-import { focusIndexBeforeResidue, landedPasteOffset, trackedPasteCaret } from './focus-target';
+import { focusIndexBeforeResidue, landedPastePosition, trackedPasteCaret } from './focus-target';
 import { docPathFrom } from '../../cursor/coordinate-spaces';
 import { resolveParentScope } from './parent-scope';
 /**
- * The break-out plan, or null: requires a top block declaring `containerPaste.siblingAbsorb`
- * whose `matchesAncestor` REJECTS the nearest list ancestor (matching pastes belong to
- * `list-absorb` and must not also trigger here), targeting a direct leaf of the listItem.
+ * The break-out plan when a top block declaring `containerPaste.siblingAbsorb` does not match the
+ * nearest list and the target is a direct leaf of its item; null otherwise.
  */
 export function findListBreakOut(doc, targetPath, parsed, offset, targetRaw) {
     if (parsed.children.length === 0)
@@ -47,25 +44,26 @@ export function findListBreakOut(doc, targetPath, parsed, offset, targetRaw) {
  * Split the enclosing list at the target item and splice the pasted blocks between the
  * halves at the list's parent level, in one multi-scope entry.
  */
-export async function applyListBreakOut(plan, pastedBlocks, ctx) {
+export async function applyListBreakOut(plan, pastedBlocks, ctx, start) {
     const list = nodeAt(ctx.doc, plan.listPath);
     if (!list?.children)
         return;
-    const { replacement, hasTrailingResidue } = buildListBreakOutReplacement(list, plan.itemIndex, plan.innerIndex, plan.offset, pastedBlocks, plan.targetRaw);
+    const lineEnding = documentLineEnding(ctx.doc);
+    const { replacement, hasTrailingResidue } = buildListBreakOutReplacement(list, plan.itemIndex, plan.innerIndex, plan.offset, pastedBlocks, lineEnding, plan.targetRaw, ctx.reading.grammar);
     if (replacement.length === 0)
         return;
     for (const node of replacement)
-        ensureEditableContainers(node);
+        ensureEditableContainers(node, lineEnding);
     const parentScope = resolveParentScope(ctx.doc, plan.listPath, ctx.controller);
     if (!parentScope)
         return;
     const spliceIndex = plan.listPath[plan.listPath.length - 1];
-    // The last pasted block, never the second-half residue list — and carried through the settle,
-    // whose folds can move the slot out from under a landing chosen here.
+    // The last pasted block, never the second-half residue list, and kept updated through the
+    // fix-up, whose merges can move the position out from under a caret chosen here.
     const caret = trackedPasteCaret(replacement, spliceIndex, focusIndexBeforeResidue(replacement.length, hasTrailingResidue), CURSOR_END);
     await ctx.controller.commitMultiScope({
         scopes: [parentScope],
-        snapshot: ctx.undoEntry === 'join' ? 'skip' : { path: docPathFrom(plan.listPath), offset: 0 },
+        snapshot: start,
         mutate: ([scopeView]) => {
             spliceMany(scopeView.children, spliceIndex, 1, replacement);
             const change = {
@@ -83,25 +81,28 @@ export async function applyListBreakOut(plan, pastedBlocks, ctx) {
             eventPath: docPathFrom(plan.listPath)
         },
         trackCaret: [caret],
-        afterTick: () => {
+        landing: () => {
             const landed = nodeAt(ctx.doc, parentScope.path)?.children?.[caret.index];
-            return ctx.controller.landCaret([...parentScope.path, caret.index], landedPasteOffset(landed, caret, CURSOR_END));
+            const at = landedPastePosition(landed, caret, CURSOR_END);
+            return {
+                path: docPathFrom([...parentScope.path, caret.index, ...at.path]),
+                offset: at.offset
+            };
         }
     });
 }
 /**
- * Split `list` at `(itemIndex, innerIndex, offset)` and splice `pastedBlocks` between the
- * halves. `hasTrailingResidue` lets the caller land the caret on the last pasted block
- * rather than the residue. Input nodes are cloned, not mutated.
+ * Split `list` at `(itemIndex, innerIndex, offset)` and splice `pastedBlocks` between the halves,
+ * cloning every input node rather than mutating it.
  */
-export function buildListBreakOutReplacement(list, itemIndex, innerIndex, offset, pastedBlocks, targetRaw) {
+export function buildListBreakOutReplacement(list, itemIndex, innerIndex, offset, pastedBlocks, ending, targetRaw, grammar) {
     const items = list.children ?? [];
     const item = items[itemIndex];
     if (!item?.children)
         return { replacement: [], hasTrailingResidue: false };
     if (!item.children[innerIndex])
         return { replacement: [], hasTrailingResidue: false };
-    const { leadingItem, trailingItem } = buildSplitItems(item, innerIndex, offset, targetRaw);
+    const { leadingItem, trailingItem } = buildSplitItems(item, innerIndex, offset, ending, targetRaw, grammar);
     const itemsBefore = items.slice(0, itemIndex).map(cloneNode);
     const itemsAfter = items.slice(itemIndex + 1).map(cloneNode);
     if (itemsAfter[0])
@@ -115,17 +116,8 @@ export function buildListBreakOutReplacement(list, itemIndex, innerIndex, offset
     if (firstHalfItems.length > 0) {
         replacement.push(assembleListHalf(list, firstHalfItems, base));
     }
-    for (const block of pastedBlocks) {
-        const cloned = cloneNode(block);
-        // Normalize the clone's items so its rebuilt raw can't mash into the next block.
-        // The ending comes from the list being broken out of — the pasted block lands
-        // among its lines.
-        if (cloned.kind === 'list' && cloned.children) {
-            newlineTerminateListItems(cloned.children, trailingLineEnding(list.raw));
-            rebuildListRaw(cloned);
-        }
-        replacement.push(cloned);
-    }
+    for (const block of pastedBlocks)
+        replacement.push(cloneNode(block));
     const hasTrailingResidue = secondHalfItems.length > 0;
     if (hasTrailingResidue) {
         // Continue numbering across the paste gap: the split item consumes one slot in each

package/dist/tree-operations/paste/parent-scope.d.ts

@@ -1,17 +1,13 @@
 /**
- * The commit scope a paste addresses when it re-mints or splices a block: the block's
- * PARENT container, resolved from the path rather than from whatever `blockEdit` is in
- * scope — a caller holding a nested-bundle blockEdit would misroute through the wrong
- * container.
+ * The commit scope a paste addresses when it splices at a block's parent container, resolved from
+ * the path rather than from whatever `blockEdit` is in scope, since a caller holding a nested
+ * bundle's `blockEdit` would go through the wrong container.
  */
-import type { CstNode, Document } from '../../core/nodes';
+import type { Document } from '../../core/nodes';
+import type { NodeView } from '../../core/node-views';
 import type { MultiScopeTarget, PasteCommitCoordinator } from './paste-deps';
 /** Null when `blockPath`'s parent doesn't resolve to a container. */
 export declare function resolveParentScope(doc: Document, blockPath: number[], controller: PasteCommitCoordinator): MultiScopeTarget | null;
-/**
- * A container's mounted `BlockListState`, or a detached stand-in. Never `expectState`:
- * these routes can be a cross-block paste whose range delete ALREADY committed, so a throw
- * would leave the selection deleted and nothing pasted. The ceremony writes ids to the
- * owned node's `childIds`, so only ref alignment is lost on the stand-in.
- */
-export declare function containerScopeState(controller: PasteCommitCoordinator, node: CstNode): MultiScopeTarget['state'];
+/** A container's mounted `BlockListState`, or its ids and no refs: unmounted is normal after a
+ *  gesture's earlier commit, and every caller lands its caret by path, so no ref is missed. */
+export declare function containerScopeState(controller: Pick<PasteCommitCoordinator, 'resolveState'>, node: NodeView): MultiScopeTarget['state'];

package/dist/tree-operations/paste/parent-scope.js

@@ -1,11 +1,9 @@
 /**
- * The commit scope a paste addresses when it re-mints or splices a block: the block's
- * PARENT container, resolved from the path rather than from whatever `blockEdit` is in
- * scope — a caller holding a nested-bundle blockEdit would misroute through the wrong
- * container.
+ * The commit scope a paste addresses when it splices at a block's parent container, resolved from
+ * the path rather than from whatever `blockEdit` is in scope, since a caller holding a nested
+ * bundle's `blockEdit` would go through the wrong container.
  */
 import { nodeAt } from '../node-primitives';
-import { devWarn } from '../../dev-warn';
 /** Null when `blockPath`'s parent doesn't resolve to a container. */
 export function resolveParentScope(doc, blockPath, controller) {
     const parentPath = blockPath.slice(0, -1);
@@ -20,16 +18,11 @@ export function resolveParentScope(doc, blockPath, controller) {
         path: parentPath
     };
 }
-/**
- * A container's mounted `BlockListState`, or a detached stand-in. Never `expectState`:
- * these routes can be a cross-block paste whose range delete ALREADY committed, so a throw
- * would leave the selection deleted and nothing pasted. The ceremony writes ids to the
- * owned node's `childIds`, so only ref alignment is lost on the stand-in.
- */
+/** A container's mounted `BlockListState`, or its ids and no refs: unmounted is normal after a
+ *  gesture's earlier commit, and every caller lands its caret by path, so no ref is missed. */
 export function containerScopeState(controller, node) {
-    const mounted = controller.resolveState(node);
-    if (mounted)
-        return mounted;
-    devWarn('paste', `committing at an unmounted ${node.kind} scope — ids realign, component refs do not`);
-    return { innerBlockIds: [...(node.childIds ?? [])], innerBlockRefs: [] };
+    return (controller.resolveState(node) ?? {
+        innerBlockIds: [...(node.childIds ?? [])],
+        innerBlockRefs: []
+    });
 }

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

@@ -3,18 +3,23 @@
  * which is what keeps the `tree-operations -> editor-actions` and
  * `tree-operations -> reactivity` back-edges out of the graph.
  */
-import type { CommitMultiScopeArgs, MultiScopeTarget } from '../../action-contracts';
+import type { CommitMultiScopeArgs, LeafTextOptions, LeafWriteResult, MultiScopeTarget, ReplaceFocus, ReplaceSource } from '../../action-contracts';
 import type { CstNode } from '../../core/nodes';
+import type { NodeView } from '../../core/node-views';
 export type { CommitMultiScopeArgs, MultiScopeTarget };
 export interface PasteCommitCoordinator {
-    commitMultiScope<const S extends readonly MultiScopeTarget[]>(args: CommitMultiScopeArgs<S>): Promise<void>;
+    commitMultiScope<const S extends readonly MultiScopeTarget[]>(args: CommitMultiScopeArgs<S>): Promise<boolean>;
     getDocScope(): MultiScopeTarget;
     /** Resolve a container node to its mounted reactive state. */
-    resolveState(node: CstNode): MultiScopeTarget['state'] | undefined;
-    /**
-     * Land the caret at a doc-absolute path, revealing an off-window target first. A
-     * structural paste lands at the END of the pasted run, so its target index scales with
-     * the clipboard and a sync ref lookup would no-op past the window's overscan (VR-12).
-     */
-    landCaret(path: number[], offset: number): Promise<void>;
+    resolveState(node: NodeView): MultiScopeTarget['state'] | undefined;
+    /** Write `text` into the leaf at `leafPath` as one commit at its parent list, through the write
+     *  every keystroke takes. */
+    commitLeafText(leafPath: number[], text: string, opts: LeafTextOptions): Promise<LeafWriteResult>;
+    /** Replace the block at `blockPath` as one commit at its parent list, resolving to how many blocks
+     *  landed or null; `snapshotOffset` is undo's caret in the block when nothing is focused. */
+    replaceBlock(blockPath: number[], replacement: CstNode[], focus: ReplaceFocus, opts: {
+        source: ReplaceSource;
+        trailingBlank?: boolean;
+        snapshotOffset: number;
+    }): Promise<number | null>;
 }

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

@@ -1,8 +1,25 @@
 /**
  * Replacement node list for a multi-block paste into a single leaf: the leaf's raw split
- * at the cursor, with the pasted blocks between the slices. STRUCTURAL pastes only —
- * routing a single-paragraph clipboard here would split it into three nodes.
+ * at the cursor, with the pasted blocks between the slices. Structural pastes only: routing
+ * a single-paragraph clipboard here would split it into three nodes.
  */
 import type { CstNode } from '../../core/nodes';
 import type { NodeView } from '../../core/node-views';
-export declare function buildPastedReplacement(leaf: NodeView, offset: number, blocks: CstNode[]): CstNode[];
+import { type LineEnding } from '../../core/lines';
+import type { GrammarView } from '../../schema/block-openers';
+import { type ChildSlot } from '../list/task-paragraph';
+export interface PastedReplacement {
+    nodes: CstNode[];
+    /** Index of the last pasted block in `nodes`, where the caret lands. */
+    lastPastedIndex: number;
+}
+/** `slot` is where the leaf sits; the leaf's own text around the pasted blocks is read the way a
+ *  reload reads it at the slot it lands in. */
+export declare function buildPastedReplacement(leaf: NodeView, offset: number, blocks: CstNode[], ending: LineEnding, grammar: GrammarView, slot: ChildSlot): PastedReplacement;
+/** The clipboard's blocks as they land after `prev`; the commit ends the last one's line. */
+export declare function landClipboardBlocks(prev: CstNode | undefined, blocks: readonly CstNode[], lineEnding: '\n' | '\r\n'): CstNode[];
+/**
+ * A copy of `block` landing after `prev`, given a blank line where the clipboard gave none, or it
+ * would continue `prev` on reload; a blank `prev` already separates it.
+ */
+export declare function landedAfter(prev: CstNode, block: CstNode, lineEnding: '\n' | '\r\n'): CstNode;

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

@@ -1,60 +1,91 @@
 /**
  * Replacement node list for a multi-block paste into a single leaf: the leaf's raw split
- * at the cursor, with the pasted blocks between the slices. STRUCTURAL pastes only —
- * routing a single-paragraph clipboard here would split it into three nodes.
+ * at the cursor, with the pasted blocks between the slices. Structural pastes only: routing
+ * a single-paragraph clipboard here would split it into three nodes.
  */
-import { snapToScalarBoundary, trailingLineEnding, trimTrailingLineEnding } from '../../core/lines';
-import { isBlankParagraph } from '../../core/parser';
+import { ownTrailingLineEnding, trailingLineEnding } from '../../core/lines';
+import { isBlankParagraph, readBlocks } from '../../core/parser';
 import { ensureEditableContainers } from '../node-primitives';
-import { parseFirstBlock } from '../parse-block';
-export function buildPastedReplacement(leaf, offset, blocks) {
+import { parseCutResidue, parseFirstBlock } from '../parse-block';
+import { cutKeepingStructure } from '../structural-suffix';
+import { fragmentReaderAt } from '../list/task-paragraph';
+/** `slot` is where the leaf sits; the leaf's own text around the pasted blocks is read the way a
+ *  reload reads it at the slot it lands in. */
+export function buildPastedReplacement(leaf, offset, blocks, ending, grammar, slot) {
     if (blocks.length === 0)
-        return [];
+        return { nodes: [], lastPastedIndex: -1 };
     const leafRaw = leaf.raw;
-    const lineEnding = trailingLineEnding(leafRaw);
-    const display = trimTrailingLineEnding(leafRaw);
-    // Off any scalar interior before the cut: the halves land in DIFFERENT blocks, so a pair
-    // split here is unrecoverable bytes rather than a recoverable edit.
-    const cut = snapToScalarBoundary(display, offset);
-    const rawBefore = display.slice(0, cut);
-    const rawAfter = display.slice(cut);
+    const lineEnding = trailingLineEnding(leafRaw, ending);
+    const { head: rawBefore, rest } = cutKeepingStructure(leaf, offset);
+    const readAt = (index) => fragmentReaderAt(slot.owner, slot.index + index, grammar);
+    // At least one pasted block lands before the residue.
+    const residue = parseCutResidue(rest, lineEnding, readAt(1));
     const originalTrivia = leaf.leadingTrivia ?? '';
     const newNodes = [];
-    // Re-parsed so heading/list leaves round-trip through their own parser rather than
-    // being forced back to a paragraph.
+    // A heading stays one, and a to-do's text stays its paragraph.
     if (rawBefore.length > 0) {
         const beforeRaw = rawBefore + lineEnding;
-        const beforeNode = parseFirstBlock(beforeRaw);
+        const beforeNode = parseFirstBlock(beforeRaw, readAt(0));
         beforeNode.leadingTrivia = originalTrivia;
-        ensureEditableContainers(beforeNode);
+        ensureEditableContainers(beforeNode, lineEnding);
         newNodes.push(beforeNode);
     }
-    // A blank-line separator is forced where source trivia is empty, or the block butts
-    // against its predecessor via a soft break and renders as one merged paragraph. A blank
-    // predecessor already holds a run open, so its successor takes no separator of its own.
-    for (let i = 0; i < blocks.length; i++) {
-        const node = { ...blocks[i] };
-        const prev = newNodes[newNodes.length - 1];
-        if (newNodes.length === 0) {
-            node.leadingTrivia = originalTrivia;
-        }
-        else if (prev !== undefined && isBlankParagraph(prev)) {
-            node.leadingTrivia = blocks[i].leadingTrivia ?? '';
+    const hasResidue = residue.blocks.length > 0;
+    const landed = landClipboardBlocks(newNodes.at(-1), blocks, lineEnding);
+    if (newNodes.length === 0)
+        landed[0].leadingTrivia = originalTrivia;
+    // Appended, never spread: a paste can outnumber an argument list (G4.60).
+    for (const node of landed)
+        newNodes.push(node);
+    const lastPastedIndex = newNodes.length - 1;
+    if (hasResidue) {
+        const [first, ...rest] = residue.blocks;
+        const lastPasted = newNodes[lastPastedIndex];
+        // An open last pasted block sits on the cut line, so the rest of that line, blank or just its
+        // break, ends it; a closed one is followed by the cut line's break as a blank line.
+        const onCutLine = ownTrailingLineEnding(lastPasted.raw) === '';
+        const blankTail = !residue.endedLine && rest.length === 0 && isBlankParagraph(first);
+        const cutLineEnd = residue.endedLine || (onCutLine && blankTail ? first.raw : lineEnding);
+        if (onCutLine)
+            newNodes[lastPastedIndex] = endedOnCutLine(lastPasted, cutLineEnd, grammar);
+        if (!onCutLine || !blankTail) {
+            newNodes.push({ ...first, leadingTrivia: onCutLine ? '' : cutLineEnd });
         }
-        else {
-            node.leadingTrivia = blocks[i].leadingTrivia ? blocks[i].leadingTrivia : lineEnding;
+        for (const node of rest)
+            newNodes.push(node);
+        for (let i = lastPastedIndex + 1; i < newNodes.length; i++) {
+            ensureEditableContainers(newNodes[i], lineEnding);
         }
-        ensureEditableContainers(node);
-        newNodes.push(node);
     }
-    // Separate node rather than merged into the last pasted block, which would let a
-    // non-paragraph tail absorb it as a continuation line.
-    if (rawAfter.length > 0) {
-        const afterRaw = rawAfter + lineEnding;
-        const afterNode = parseFirstBlock(afterRaw);
-        afterNode.leadingTrivia = lineEnding;
-        ensureEditableContainers(afterNode);
-        newNodes.push(afterNode);
+    return { nodes: newNodes, lastPastedIndex };
+}
+/** `node` with the rest of the line it was pasted into, read back as the one block it still is. */
+function endedOnCutLine(node, cutLineEnd, grammar) {
+    const lineEnding = trailingLineEnding(cutLineEnd, '\n');
+    // The clipboard's own block keeps the kind the clipboard's parse gave it, as every other pasted
+    // block does; what that does to a checkbox it lands behind is #624's question.
+    const ended = parseFirstBlock(node.raw + cutLineEnd, (text) => readBlocks(text, { grammar, scope: 'fragment' }));
+    ended.leadingTrivia = node.leadingTrivia;
+    ensureEditableContainers(ended, lineEnding);
+    return ended;
+}
+/** The clipboard's blocks as they land after `prev`; the commit ends the last one's line. */
+export function landClipboardBlocks(prev, blocks, lineEnding) {
+    const landed = [];
+    for (let i = 0; i < blocks.length; i++) {
+        // The clipboard's parse already read its own blocks as themselves, so only the join with
+        // the text above is new.
+        const node = i === 0 && prev ? landedAfter(prev, blocks[i], lineEnding) : { ...blocks[i] };
+        ensureEditableContainers(node, lineEnding);
+        landed.push(node);
     }
-    return newNodes;
+    return landed;
+}
+/**
+ * A copy of `block` landing after `prev`, given a blank line where the clipboard gave none, or it
+ * would continue `prev` on reload; a blank `prev` already separates it.
+ */
+export function landedAfter(prev, block, lineEnding) {
+    const separated = block.leadingTrivia !== '' || isBlankParagraph(prev);
+    return { ...block, leadingTrivia: separated ? block.leadingTrivia : lineEnding };
 }

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

@@ -1,6 +1,6 @@
 /**
  * Content-keyed, pre-parse paste transforms: a plugin registers a named transform that
- * rewrites the raw clipboard text or declines. Register-once, throw-on-duplicate — the
+ * rewrites the raw clipboard text or declines. Register-once, throw-on-duplicate, the
  * `customElements` model shared with `paste-surfaces.ts`.
  */
 import type { PluginActivation } from '../../schema/plugin-activation';
@@ -12,14 +12,12 @@ export interface PasteTransform {
 }
 export declare function registerPasteTransform(transform: PasteTransform): void;
 /**
- * Non-throwing registration probe, so an idempotent module (HMR, a re-imported registrar) asks
+ * Non-throwing registration check, so an idempotent module (HMR, a re-imported registrar) asks
  * before registering instead of catching the duplicate throw.
  */
 export declare function isPasteTransformRegistered(name: string): boolean;
 /**
- * Run every transform over `text` in registration order, each seeing the prior's output;
- * a null return leaves the running text untouched. `activation` scopes the run to one
- * instance's plugins; absent = every installed one. A transform no plugin owns always runs.
+ * Run every transform `activation` resolves over `text`, its line breaks made LF, in registration
+ * order, each seeing the prior's output; a null return leaves the running text untouched.
  */
-export declare function applyPasteTransforms(text: string, activation?: PluginActivation): string;
-export declare function __resetPasteTransformsForTests(): void;
+export declare function applyPasteTransforms(text: string, activation: PluginActivation): string;

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

@@ -1,35 +1,32 @@
-import { currentInstallingPlugin } from '../../schema/plugin-install';
-import { registerOnce } from '../../schema/register-once';
+import { createPluginRegistry } from '../../schema/plugin-registry';
 import { devWarn } from '../../dev-warn';
 import { editorEnv } from '../../env';
-// Map iteration is insertion order, so `.values()` is the pipeline order while the keyed
-// lookup guards duplicates — one structure, no parallel array.
-const transforms = new Map();
+import { normalizeLineEndings } from '../../core/lines';
+// Registration order is the pipeline order.
+const transforms = createPluginRegistry({
+    label: 'registerPasteTransform',
+    isBuiltin: () => false
+});
 export function registerPasteTransform(transform) {
-    const existing = transforms.get(transform.name);
-    registerOnce(existing !== undefined, () => transforms.set(transform.name, { transform, owner: currentInstallingPlugin() }), `registerPasteTransform: "${transform.name}" is already registered` +
-        (existing?.owner ? ` by plugin '${existing.owner}'` : '') +
+    const owner = transforms.ownerOf(transform.name);
+    transforms.register(transform.name, transform, `registerPasteTransform: "${transform.name}" is already registered` +
+        (owner ? ` by plugin '${owner}'` : '') +
         `. Paste transforms are register-once.`);
 }
 /**
- * Non-throwing registration probe, so an idempotent module (HMR, a re-imported registrar) asks
+ * Non-throwing registration check, so an idempotent module (HMR, a re-imported registrar) asks
  * before registering instead of catching the duplicate throw.
  */
 export function isPasteTransformRegistered(name) {
     return transforms.has(name);
 }
 /**
- * Run every transform over `text` in registration order, each seeing the prior's output;
- * a null return leaves the running text untouched. `activation` scopes the run to one
- * instance's plugins; absent = every installed one. A transform no plugin owns always runs.
+ * Run every transform `activation` resolves over `text`, its line breaks made LF, in registration
+ * order, each seeing the prior's output; a null return leaves the running text untouched.
  */
 export function applyPasteTransforms(text, activation) {
-    if (transforms.size === 0)
-        return text;
-    let result = text;
-    for (const { transform, owner } of transforms.values()) {
-        if (owner !== null && activation && !activation.isActive(owner))
-            continue;
+    let result = normalizeLineEndings(text);
+    for (const [, transform] of transforms.entries(activation)) {
         const next = runContained(transform, result, 'pipeline');
         if (next === null)
             continue;
@@ -38,15 +35,9 @@ export function applyPasteTransforms(text, activation) {
     }
     return result;
 }
-export function __resetPasteTransformsForTests() {
-    transforms.clear();
-}
 /**
- * The one door plugin `transform()` code is called through. On the cross-block route the
- * covering range delete has already committed, so an escaping throw would leave the
- * selection deleted and nothing pasted; a throw becomes the null a decline returns. The
- * warning names its phase because a probe-time throw read as a decline would send the
- * author debugging a paste that worked.
+ * The one place plugin `transform()` code runs. A throw becomes a decline, since on the
+ * cross-block route the range delete has already committed and would leave nothing pasted.
  */
 function runContained(transform, text, phase) {
     try {
@@ -67,6 +58,6 @@ function warnIfNonIdempotent(transform, result) {
         return;
     const again = runContained(transform, result, 'probe');
     if (again !== null && again !== result) {
-        devWarn('paste-transform', `transform '${transform.name}' is not idempotent — re-running it on its own output changed the text again`);
+        devWarn('paste-transform', `transform '${transform.name}' is not idempotent: re-running it on its own output changed the text again`);
     }
 }

package/dist/tree-operations/paste/replacement-parse.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The bytes a block is replaced by, parsed the one way every replace-at-parent caller needs them:
+ * their line breaks in the document's ending, terminated in the original's own ending, else the
+ * document's, read the way a reload reads the original's slot, carrying the original's leading
+ * blank lines, with editable containers ensured.
+ */
+import type { CstNode } from '../../core/nodes';
+import type { FragmentReader } from '../list/task-paragraph';
+import { type LineEnding } from '../../core/lines';
+export interface ParsedReplacement {
+    replacement: CstNode[];
+    /** The parse's own trailing blank, for a caller that lands one (`paste/dispatch.ts`). */
+    suffix: string;
+}
+/**
+ * `read` is the original's slot reader (`fragmentReaderAt`). Null where `raw` parses to nothing
+ * and the caller named no `fallback`: the block keeps its bytes rather than an empty splice.
+ */
+export declare function parseReplacement(original: CstNode, raw: string, ending: LineEnding, read: FragmentReader, fallback?: () => CstNode[]): ParsedReplacement | null;

package/dist/tree-operations/paste/replacement-parse.js

@@ -0,0 +1,24 @@
+/**
+ * The bytes a block is replaced by, parsed the one way every replace-at-parent caller needs them:
+ * their line breaks in the document's ending, terminated in the original's own ending, else the
+ * document's, read the way a reload reads the original's slot, carrying the original's leading
+ * blank lines, with editable containers ensured.
+ */
+import { terminateLine, trailingLineEnding, withLineEnding } from '../../core/lines';
+import { ensureEditableContainers, normalizeReplacementTrivia } from '../node-primitives';
+/**
+ * `read` is the original's slot reader (`fragmentReaderAt`). Null where `raw` parses to nothing
+ * and the caller named no `fallback`: the block keeps its bytes rather than an empty splice.
+ */
+export function parseReplacement(original, raw, ending, read, fallback) {
+    const lineEnding = trailingLineEnding(original.raw, ending);
+    const bytes = terminateLine(withLineEnding(raw, ending), lineEnding);
+    const parsed = read(bytes);
+    const children = parsed.children.length > 0 ? parsed.children : fallback?.();
+    if (!children || children.length === 0)
+        return null;
+    const replacement = normalizeReplacementTrivia(original, children);
+    for (const node of replacement)
+        ensureEditableContainers(node, lineEnding);
+    return { replacement, suffix: parsed.suffix };
+}

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

@@ -2,7 +2,7 @@ import type { CstNode } from '../../core/nodes';
 import type { PasteStrategy } from './dispatch';
 /**
  * The clipboard's content blocks: a blank block at either edge is the copy's packaging, which a
- * surface holding no blocks classifies past. Empty when nothing but packaging came across.
+ * kind that holds no blocks skips over. Empty when nothing but packaging came across.
  */
 export declare function contentBlocks(blocks: readonly CstNode[]): readonly CstNode[];
 /** One paragraph is text any leaf can take inline; anything else is structure. */

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

@@ -1,7 +1,7 @@
 import { isBlankParagraph } from '../../core/parser';
 /**
  * The clipboard's content blocks: a blank block at either edge is the copy's packaging, which a
- * surface holding no blocks classifies past. Empty when nothing but packaging came across.
+ * kind that holds no blocks skips over. Empty when nothing but packaging came across.
  */
 export function contentBlocks(blocks) {
     let start = 0;