@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/tree-operations/node-primitives.d.ts

@@ -1,60 +1,73 @@
 /**
- * The parent shapes, mints and path walks under every tree op. Children-array contract: an op
- * mutating a container's top-level children takes the array as a parameter and mutates that,
- * never `node.children` (the caller owns and republishes it, so a direct splice is overwritten).
- * A descendant found by walking the live tree is the exception: mutate it in place on a
- * caller-unshared spine (`unshare.ts`), a STRUCTURAL one via `commitMultiScope`.
+ * The parent shapes, node constructors and path walks under every tree op. An op mutating a
+ * container's children takes the array as a parameter, never `node.children`, which the caller
+ * owns and writes back; a descendant found by walking the live tree is mutated in place after its
+ * ancestors are copied (`unshare.ts`), or through `commitMultiScope` when the change is structural.
  */
-import type { AnyBlockKind, CstNode, Document } from '../core/nodes';
+import type { CstNode, Document } from '../core/nodes';
 import type { DocumentView, NodeView } from '../core/node-views';
 import type { GrammarView } from '../schema/block-openers';
+import { type LineEnding } from '../core/lines';
 /** A children array an op mutates structurally: splice, delete, reorder. */
 export type NodeParent = {
     children: CstNode[];
 };
 /**
- * A {@link NodeParent} that has answered which container owns it, for the owner's `bodyWrite`
- * grammar and wrap slots. Nullable, not optional: skipping the question is a compile error.
+ * A {@link NodeParent} that names the container owning it, for the owner's `bodyWrite` rule and
+ * `innerPrefix`/`innerSuffix`. Nullable, not optional: leaving the owner out is a compile error.
  */
 export type BodyParent = NodeParent & {
-    ownerKind: AnyBlockKind | undefined;
+    /** The container these children belong to; undefined is the document root, which has no rule. */
     owner: CstNode | undefined;
+    /** The document's line ending, which every line an op writes into these children takes. */
+    lineEnding: LineEnding;
     suffix?: string;
 };
-/** What the byte sinks accept: a whole `Document` IS the answer (the root owns no body grammar). */
+/** What the content writes accept: a whole `Document` counts as one (the root has no body rule). */
 export type BodyParentArg = BodyParent | Document;
 /**
- * What the separator settles accept: anything that can answer where the body starts. Wider than
- * the byte sinks, since a settle writes a line ending, not body text.
+ * The document as a body: its children (the commit's working copy, when given) and its trailing
+ * blank line, read and written through to the live document so a rollback restores it.
+ */
+export declare function documentBody(doc: Document, children?: CstNode[]): Document & BodyParent;
+/**
+ * What the separator fix-ups accept: anything that can say where the body starts. Wider than
+ * the content writes, since a fix-up writes a line ending, not body text.
  */
 export type SeparatorParent = {
     kind?: string;
-    ownerKind?: AnyBlockKind;
     suffix?: string;
     children?: CstNode[];
     owner?: CstNode;
 };
-/** Text made legal as a child's raw inside a container of kind `ownerKind`. */
-export declare function normalizeBodyWrite(ownerKind: AnyBlockKind | undefined, raw: string): string;
-/** {@link normalizeBodyWrite} for a sink holding the parent rather than the owner's kind. */
+/** The line ending an op writing into `parent`'s children gives a new line. */
+export declare const parentLineEnding: (parent: BodyParentArg) => LineEnding;
+/**
+ * Text made legal as a child's raw inside `owner`'s body. A child's bytes are never the
+ * container's own syntax, so the write is always `literal`.
+ */
+export declare function normalizeBodyWrite(owner: NodeView | undefined, raw: string, lineEnding: LineEnding): string;
+/** {@link normalizeBodyWrite} for a caller holding the parent rather than the owner. */
 export declare const forBody: (parent: BodyParentArg, raw: string) => string;
 /**
- * `raw` made legal as `node`'s OWN bytes, for a sink that REPLACES the node with a reparse: the
- * reparse re-derives metadata, so structure the rule restores from the old metadata lands first.
+ * `raw` made legal as `node`'s own bytes before a reparse replaces the node; the rule runs first
+ * because it reads the node's metadata as it stands, which the reparse re-derives.
  */
-export declare function normalizeOwnRaw(node: NodeView, raw: string): string;
+export declare function normalizeOwnRaw(node: NodeView, raw: string, lineEnding: LineEnding): string;
 /**
- * Write `raw` as `node`'s OWN bytes through its kind's rule, in place. Every sink writing a
- * leaf's bytes without the kind's surface in front of it owes this or {@link normalizeOwnRaw}.
+ * Write `raw` as `node`'s own bytes through its kind's rule, in place. Every write of a leaf's
+ * bytes that bypasses the kind's editable element must go through here or {@link normalizeOwnRaw}.
  */
-export declare function writeOwnRaw(node: CstNode, raw: string, grammar: GrammarView | undefined): void;
+export declare function writeOwnRaw(node: CstNode, raw: string, lineEnding: LineEnding, grammar: GrammarView): void;
+/** Bytes already made legal for `node`, written in place with its parse-owned metadata. */
+export declare function installOwnRaw(node: CstNode, legal: string, grammar: GrammarView): void;
 /**
- * Every argument is required: a paragraph's raw ENDS in a line ending, so a mint site answers
- * which document it lands in (G4.20). Fresh every call, or a shared instance aliases across
- * tree positions (G1.9).
+ * A fresh object every call, since one instance at two tree positions would share its bytes
+ * (G1.9). `lineEnding` is required because a paragraph's raw ends in the document's ending.
  */
 export declare function paragraphNode(leadingTrivia: string, text: string, lineEnding: string): CstNode;
-/** The empty-paragraph placeholder keeping an emptied document or container caret-addressable. */
+/** An empty paragraph: the one block an emptied document keeps, and the backfill for a container a
+ *  parse or a write builds with no children (one a delete empties is removed instead). */
 export declare function emptyParagraph(leadingTrivia: string, lineEnding: string): CstNode;
 export declare function nodeAt(doc: Document, path: number[]): CstNode | Document | null;
 export declare function nodeAt(doc: DocumentView, path: number[]): NodeView | DocumentView | null;
@@ -64,12 +77,12 @@ export declare function blockNodeAt(doc: DocumentView, path: number[]): NodeView
 export declare function isBlockNode(node: CstNode | Document): node is CstNode;
 export declare function isBlockNode(node: NodeView | DocumentView): node is NodeView;
 /**
- * The stand-in for whatever the user types next: the maximally-continuable line, so a probe
- * answers for the worst case. Openers are arbitrary code, so `probeLineOpensAsProse` is the
- * runtime check that it still reads as prose.
+ * The stand-in for whatever the user types next, the line most likely to continue any block;
+ * `probeLineOpensAsProse` checks at runtime that no registered opener claims it.
  */
 export declare const NEXT_PROSE_LINE = "x";
 /** First node inherits the original block's leadingTrivia; subsequent nodes keep theirs. */
 export declare function normalizeReplacementTrivia(original: CstNode, replacement: CstNode[]): CstNode[];
-/** Ensure every container has at least one child block, so the cursor always has a target. */
-export declare function ensureEditableContainers(node: CstNode): void;
+/** Give every container that must hold a child an empty paragraph, so the caret always has a
+ *  target. A container with no bytes yet backfills its lines in `ending`, the document's. */
+export declare function ensureEditableContainers(node: CstNode, ending: LineEnding): void;

package/dist/tree-operations/node-primitives.js

@@ -1,56 +1,83 @@
 /**
- * The parent shapes, mints and path walks under every tree op. Children-array contract: an op
- * mutating a container's top-level children takes the array as a parameter and mutates that,
- * never `node.children` (the caller owns and republishes it, so a direct splice is overwritten).
- * A descendant found by walking the live tree is the exception: mutate it in place on a
- * caller-unshared spine (`unshare.ts`), a STRUCTURAL one via `commitMultiScope`.
+ * The parent shapes, node constructors and path walks under every tree op. An op mutating a
+ * container's children takes the array as a parameter, never `node.children`, which the caller
+ * owns and writes back; a descendant found by walking the live tree is mutated in place after its
+ * ancestors are copied (`unshare.ts`), or through `commitMultiScope` when the change is structural.
  */
-import { parse } from '../core/parser';
-import { trailingLineEnding } from '../core/lines';
-import { getBlockKindDescriptor, tryGetBlockKindDescriptor } from '../schema/block-kind-descriptor';
+import { readBlocks } from '../core/parser';
+import { documentLineEnding, ownTrailingLineEnding, trailingLineEnding } from '../core/lines';
+import { mustHoldChild, tryGetBlockKindDescriptor } from '../schema/block-kind-descriptor';
 import { reservedChromeKindOf } from '../schema/reserved-chrome';
-const ownerKindOf = (parent) => 'ownerKind' in parent ? parent.ownerKind : undefined;
-/** Text made legal as a child's raw inside a container of kind `ownerKind`. */
-export function normalizeBodyWrite(ownerKind, raw) {
-    const owner = ownerKind === undefined ? undefined : tryGetBlockKindDescriptor(ownerKind);
-    return owner?.bodyWrite?.normalize(raw) ?? raw;
+import { adoptParsedMetadata } from '../schema/container-raw';
+/**
+ * The document as a body: its children (the commit's working copy, when given) and its trailing
+ * blank line, read and written through to the live document so a rollback restores it.
+ */
+export function documentBody(doc, children = doc.children) {
+    // No `childIds`: an op that tracks ids on its parent must not splice the live document's array.
+    return {
+        kind: 'document',
+        prefix: doc.prefix,
+        children,
+        owner: undefined,
+        lineEnding: documentLineEnding(doc),
+        get suffix() {
+            return doc.suffix;
+        },
+        set suffix(value) {
+            doc.suffix = value;
+        }
+    };
 }
-/** {@link normalizeBodyWrite} for a sink holding the parent rather than the owner's kind. */
-export const forBody = (parent, raw) => normalizeBodyWrite(ownerKindOf(parent), raw);
+/** The line ending an op writing into `parent`'s children gives a new line. */
+export const parentLineEnding = (parent) => 'lineEnding' in parent ? parent.lineEnding : documentLineEnding(parent);
 /**
- * `raw` made legal as `node`'s OWN bytes, for a sink that REPLACES the node with a reparse: the
- * reparse re-derives metadata, so structure the rule restores from the old metadata lands first.
+ * Text made legal as a child's raw inside `owner`'s body. A child's bytes are never the
+ * container's own syntax, so the write is always `literal`.
  */
-export function normalizeOwnRaw(node, raw) {
-    return tryGetBlockKindDescriptor(node.kind)?.normalizeRawWrite?.(raw, node) ?? raw;
+export function normalizeBodyWrite(owner, raw, lineEnding) {
+    if (!owner)
+        return raw;
+    const rule = tryGetBlockKindDescriptor(owner.kind)?.bodyWrite;
+    return rule ? rule.normalize(raw, { node: owner, mode: 'literal', lineEnding }) : raw;
 }
+/** {@link normalizeBodyWrite} for a caller holding the parent rather than the owner. */
+export const forBody = (parent, raw) => normalizeBodyWrite('owner' in parent ? parent.owner : undefined, raw, parentLineEnding(parent));
 /**
- * Write `raw` as `node`'s OWN bytes through its kind's rule, in place. Every sink writing a
- * leaf's bytes without the kind's surface in front of it owes this or {@link normalizeOwnRaw}.
+ * `raw` made legal as `node`'s own bytes before a reparse replaces the node; the rule runs first
+ * because it reads the node's metadata as it stands, which the reparse re-derives.
  */
-export function writeOwnRaw(node, raw, grammar) {
-    const descriptor = tryGetBlockKindDescriptor(node.kind);
-    const legal = descriptor?.normalizeRawWrite?.(raw, node) ?? raw;
+export function normalizeOwnRaw(node, raw, lineEnding) {
+    const rule = tryGetBlockKindDescriptor(node.kind)?.rawWrite;
+    return rule ? rule.normalize(raw, { node, mode: 'literal', lineEnding }) : raw;
+}
+/**
+ * Write `raw` as `node`'s own bytes through its kind's rule, in place. Every write of a leaf's
+ * bytes that bypasses the kind's editable element must go through here or {@link normalizeOwnRaw}.
+ */
+export function writeOwnRaw(node, raw, lineEnding, grammar) {
+    installOwnRaw(node, normalizeOwnRaw(node, raw, lineEnding), grammar);
+}
+/** Bytes already made legal for `node`, written in place with its parse-owned metadata. */
+export function installOwnRaw(node, legal, grammar) {
     node.raw = legal;
     // A context-dependent kind's raw does not reparse to itself, so a fragment parse would only
     // mis-read metadata that was never parse-derived.
-    if (descriptor?.contextDependentKind)
+    if (tryGetBlockKindDescriptor(node.kind)?.contextDependentKind)
         return;
     // In place means no reparse replaces the node, so parse-owned metadata re-derives here.
-    const reparsed = parse(legal, { grammar, scope: 'fragment' }).children;
-    if (reparsed.length === 1 && reparsed[0].kind === node.kind)
-        node.metadata = reparsed[0].metadata;
+    adoptParsedMetadata(node, readBlocks(legal, { grammar, scope: 'fragment' }).children);
 }
-// ── Node minting ──
+// ── Node constructors ──
 /**
- * Every argument is required: a paragraph's raw ENDS in a line ending, so a mint site answers
- * which document it lands in (G4.20). Fresh every call, or a shared instance aliases across
- * tree positions (G1.9).
+ * A fresh object every call, since one instance at two tree positions would share its bytes
+ * (G1.9). `lineEnding` is required because a paragraph's raw ends in the document's ending.
  */
 export function paragraphNode(leadingTrivia, text, lineEnding) {
     return { kind: 'paragraph', leadingTrivia, raw: text + lineEnding };
 }
-/** The empty-paragraph placeholder keeping an emptied document or container caret-addressable. */
+/** An empty paragraph: the one block an emptied document keeps, and the backfill for a container a
+ *  parse or a write builds with no children (one a delete empties is removed instead). */
 export function emptyParagraph(leadingTrivia, lineEnding) {
     return paragraphNode(leadingTrivia, '', lineEnding);
 }
@@ -72,9 +99,8 @@ export function isBlockNode(node) {
 }
 // ── Grammar stand-in and replacement shape ──
 /**
- * The stand-in for whatever the user types next: the maximally-continuable line, so a probe
- * answers for the worst case. Openers are arbitrary code, so `probeLineOpensAsProse` is the
- * runtime check that it still reads as prose.
+ * The stand-in for whatever the user types next, the line most likely to continue any block;
+ * `probeLineOpensAsProse` checks at runtime that no registered opener claims it.
  */
 export const NEXT_PROSE_LINE = 'x';
 /** First node inherits the original block's leadingTrivia; subsequent nodes keep theirs. */
@@ -87,31 +113,29 @@ export function normalizeReplacementTrivia(original, replacement) {
     });
 }
 // ── Editable container backfill ──
-/** Ensure every container has at least one child block, so the cursor always has a target. */
-export function ensureEditableContainers(node) {
-    // A whole-block-focus kind is childless by design: the block itself is the caret target,
-    // and a backfilled paragraph its raw can't account for trips opaque-stale-raw.
-    if (getBlockKindDescriptor(node.kind).blockFocus === 'whole-block')
+/** Give every container that must hold a child an empty paragraph, so the caret always has a
+ *  target. A container with no bytes yet backfills its lines in `ending`, the document's. */
+export function ensureEditableContainers(node, ending) {
+    if (!node.children)
         return;
-    if (node.children !== undefined) {
-        if (node.children.length === 0) {
-            // discovered-descendant mutation, see file header
-            const chromeKind = reservedChromeKindOf(node.kind);
-            // Backfilled lines are pure line ending, so they take the container's own (G4.20).
-            const lineEnding = trailingLineEnding(node.raw);
-            // A chrome-declaring container re-mints its child-0 leaf too, or the backfilled
-            // paragraph would occupy the reserved slot (G1.14).
-            if (chromeKind !== undefined) {
-                // Runtime chrome kind, so the mint takes the generic cast.
-                node.children.push({ kind: chromeKind, leadingTrivia: '', raw: lineEnding });
-            }
-            node.children.push(emptyParagraph('', lineEnding));
-            // The synthesized paragraph's ending already represents the blank `parseBlocks`
-            // routed into innerPrefix; keeping both double-counts the line on rebuild.
-            node.innerPrefix = '';
-        }
-        for (const child of node.children) {
-            ensureEditableContainers(child);
+    if (node.children.length === 0 && mustHoldChild(node.kind)) {
+        // An in-place write on a descendant found by walking, see the file header.
+        const chromeKind = reservedChromeKindOf(node.kind);
+        const lineEnding = trailingLineEnding(node.raw, ending);
+        // A container with a reserved title child re-creates that child too, or the backfilled
+        // paragraph would occupy its position (G1.14).
+        if (chromeKind !== undefined) {
+            // The title child's kind is only known at runtime, so the literal takes the generic cast.
+            node.children.push({ kind: chromeKind, leadingTrivia: '', raw: lineEnding });
         }
+        // The paragraph holds the container's last line, so an open last line stays open in it.
+        const lastLineEnding = node.raw === '' ? lineEnding : ownTrailingLineEnding(node.raw);
+        node.children.push(emptyParagraph('', lastLineEnding));
+        // The synthesized paragraph's ending already represents the blank `parseBlocks`
+        // routed into innerPrefix; keeping both double-counts the line on rebuild.
+        node.innerPrefix = '';
+    }
+    for (const child of node.children) {
+        ensureEditableContainers(child, ending);
     }
 }

package/dist/tree-operations/open-tail.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The document's open last line: only the last line may lack a line ending, and after a structural
+ * edit it lacks one exactly when it did before, unless that line is blank. The commit calls these
+ * steps around every structural edit, so no edit writes the tail's ending by hand
+ * (`docs/design/syntax-tree.md` § Blank lines).
+ */
+import type { Document } from '../core/nodes';
+import type { DocumentView, NodeView } from '../core/node-views';
+import type { BodyParent } from './node-primitives';
+import type { StructuralChange } from './structural-change';
+import type { SharingState } from './sharing';
+import type { GrammarView } from '../schema/block-openers';
+/** Whether the document's last line has no line ending; the commit reads it before the edit. */
+export declare function endsOpen(doc: DocumentView): boolean;
+/** Every block the change placed, and the block above them, ends its line. Run before the
+ *  separator fix-up, which reads their bytes side by side. */
+export declare function endWindowLines(body: BodyParent, change: StructuralChange, sharing: SharingState, grammar: GrammarView): void;
+/** When the document ended open before the commit, the block now last gives its ending up, unless
+ *  its last line is blank. Run after the containers rebuild, since it writes each level's raw. */
+export declare function keepOpenTail(doc: Document, wasOpen: boolean, sharing: SharingState, grammar: GrammarView): void;
+/**
+ * Whether the block that holds `node`'s last line, found down the path the release walks, ends
+ * in a blank line; a quote's own trailing `>` line is its own and has a marker, so it is not.
+ */
+export declare function holdsBlankLastLine(node: NodeView): boolean;

package/dist/tree-operations/open-tail.js

@@ -0,0 +1,100 @@
+/**
+ * The document's open last line: only the last line may lack a line ending, and after a structural
+ * edit it lacks one exactly when it did before, unless that line is blank. The commit calls these
+ * steps around every structural edit, so no edit writes the tail's ending by hand
+ * (`docs/design/syntax-tree.md` § Blank lines).
+ */
+import { endsInBlankLine, ownTrailingLineEnding, terminateLine, trimTrailingLineEnding } from '../core/lines';
+import { ensureUnsharedChild } from './unshare';
+import { dropChildSpans } from '../schema/child-spans';
+import { getBlockKindDescriptor, isGridDescriptor, isGridKind, tryGetBlockKindDescriptor } from '../schema/block-kind-descriptor';
+import { reservedChromeKindOf } from '../schema/reserved-chrome';
+import { followBytes } from '../schema/container-raw';
+// ── The commit's steps ───────────────────────────────────────────────────────
+/** Whether the document's last line has no line ending; the commit reads it before the edit. */
+export function endsOpen(doc) {
+    const last = doc.children.at(-1);
+    return doc.suffix === '' && last !== undefined && ownTrailingLineEnding(last.raw) === '';
+}
+/** Every block the change placed, and the block above them, ends its line. Run before the
+ *  separator fix-up, which reads their bytes side by side. */
+export function endWindowLines(body, change, sharing, grammar) {
+    if (change.op === 'noop')
+        return;
+    const placed = change.op === 'insert' ? change.count : change.op === 'replace' ? change.newCount : 0;
+    const children = body.children;
+    // A title row sits on the container's own opener line, so it is no line of the body's.
+    const bodyStart = body.owner && reservedChromeKindOf(body.owner.kind) ? 1 : 0;
+    const lo = Math.max(change.at - 1, bodyStart);
+    const hi = Math.min(change.at + placed, children.length);
+    for (let i = lo; i < hi; i++) {
+        if (!isLine(body.owner, children[i]) || ownTrailingLineEnding(children[i].raw) !== '')
+            continue;
+        terminateLastLine(ensureUnsharedChild(body, i, sharing), body.lineEnding, sharing, grammar);
+    }
+}
+/** When the document ended open before the commit, the block now last gives its ending up, unless
+ *  its last line is blank. Run after the containers rebuild, since it writes each level's raw. */
+export function keepOpenTail(doc, wasOpen, sharing, grammar) {
+    if (!wasOpen || doc.suffix !== '')
+        return;
+    const lastIndex = doc.children.length - 1;
+    const last = doc.children[lastIndex];
+    if (!last || ownTrailingLineEnding(last.raw) === '' || holdsBlankLastLine(last))
+        return;
+    releaseLastLine(ensureUnsharedChild(doc, lastIndex, sharing), sharing, grammar);
+}
+/**
+ * Whether the block that holds `node`'s last line, found down the path the release walks, ends
+ * in a blank line; a quote's own trailing `>` line is its own and has a marker, so it is not.
+ */
+export function holdsBlankLastLine(node) {
+    const last = node.children?.at(-1);
+    const descriptor = tryGetBlockKindDescriptor(node.kind);
+    const descends = (descriptor?.containerContract === 'strip' && !node.innerSuffix) ||
+        (isGridDescriptor(descriptor) && last !== undefined && isGridKind(last.kind));
+    return last && descends ? holdsBlankLastLine(last) : endsInBlankLine(node.raw);
+}
+// ── The walk down the last line ──────────────────────────────────────────────
+/** A row's cells sit inside one line, so only a grid's own rows count as lines of its body. */
+function isLine(owner, child) {
+    return !owner || !isGridKind(owner.kind) || isGridKind(child.kind);
+}
+/**
+ * End the node's last line in `ending`, in its own raw and in every node below holding that line,
+ * so a container's other lines (a quote's lazy continuation lines) keep their bytes.
+ */
+function terminateLastLine(node, ending, sharing, grammar) {
+    rewriteLastLine(node, (raw) => terminateLine(raw, ending), sharing, grammar);
+}
+function releaseLastLine(node, sharing, grammar) {
+    rewriteLastLine(node, trimTrailingLineEnding, sharing, grammar);
+}
+function rewriteLastLine(node, write, sharing, grammar) {
+    const wasEnded = node.raw.endsWith('\n');
+    const raw = write(node.raw);
+    if (raw === node.raw)
+        return;
+    const rawBefore = node.raw;
+    node.raw = raw;
+    // A container's metadata can hold its closing line's ending.
+    followBytes(node, rawBefore, grammar);
+    const last = (node.children?.length ?? 0) - 1;
+    if (last < 0)
+        return;
+    const descriptor = getBlockKindDescriptor(node.kind);
+    if (descriptor.containerContract === 'strip') {
+        dropChildSpans(node);
+        // A blank line closing the body is the last line; the parser keeps it out of the suffix
+        // while it is unended, so a last child already ended the other way marks it too.
+        if (node.innerSuffix || node.children[last].raw.endsWith('\n') !== wasEnded) {
+            node.innerSuffix = write(node.innerSuffix ?? '');
+            return;
+        }
+    }
+    else if (!isGridDescriptor(descriptor) || !isGridKind(node.children[last].kind)) {
+        // A grid's rows are whole lines; a row's cells and an opaque body sit inside a line.
+        return;
+    }
+    rewriteLastLine(ensureUnsharedChild(node, last, sharing), write, sharing, grammar);
+}

package/dist/tree-operations/parse-block.d.ts

@@ -1,3 +1,16 @@
 import type { CstNode } from '../core/nodes';
-/** Parse one block's `raw` and return its first block, falling back to a paragraph node. */
-export declare function parseFirstBlock(raw: string): CstNode;
+import type { FragmentReader } from './list/task-paragraph';
+/** Read one block's `raw` with the reader of the slot it lands in and return its first block,
+ *  falling back to a paragraph node. */
+export declare function parseFirstBlock(raw: string, read: FragmentReader): CstNode;
+export interface CutResidue {
+    /** The rest of the cut line with its line ending when that rest is only whitespace, else ''. */
+    endedLine: string;
+    /** Every block the text after `endedLine` parses to. */
+    blocks: CstNode[];
+}
+/**
+ * The text after a paste's cut, as blocks read with the reader of the slot they land in; a line
+ * break left at its head comes back as `endedLine`, so the caller decides where the break goes.
+ */
+export declare function parseCutResidue(text: string, lineEnding: '\n' | '\r\n', read: FragmentReader): CutResidue;

package/dist/tree-operations/parse-block.js

@@ -1,8 +1,23 @@
-import { parse } from '../core/parser';
-/** Parse one block's `raw` and return its first block, falling back to a paragraph node. */
-export function parseFirstBlock(raw) {
-    const doc = parse(raw, { scope: 'fragment' });
+import { isBlankLine } from '../core/lines';
+/** Read one block's `raw` with the reader of the slot it lands in and return its first block,
+ *  falling back to a paragraph node. */
+export function parseFirstBlock(raw, read) {
+    const doc = read(raw);
     if (doc.children.length > 0)
         return doc.children[0];
     return { kind: 'paragraph', leadingTrivia: '', raw };
 }
+/**
+ * The text after a paste's cut, as blocks read with the reader of the slot they land in; a line
+ * break left at its head comes back as `endedLine`, so the caller decides where the break goes.
+ */
+export function parseCutResidue(text, lineEnding, read) {
+    const lineBreak = /\r?\n/.exec(text);
+    const endedLine = lineBreak && isBlankLine(text.slice(0, lineBreak.index))
+        ? text.slice(0, lineBreak.index + lineBreak[0].length)
+        : '';
+    const body = text.slice(endedLine.length);
+    if (body === '')
+        return { endedLine, blocks: [] };
+    return { endedLine, blocks: read(body + lineEnding).children };
+}

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

@@ -1,12 +1,11 @@
-/** Applies the results a paste surface hook produced to the document. */
+/** Applies the results a paste surface hook produced to the document. `start` is where the paste
+ *  began, which each commit records as undo's caret. */
+import type { CommitSnapshotArg } from '../../action-contracts';
 import type { InlinePasteResult, StructuralPasteResult } from '../paste-surfaces';
 import type { PasteDispatchContext, InlineCaretLanding } from './dispatch';
 /**
- * Apply an inline paste. Single-block routes through `updateBlockContent`; cross-block
- * commits the same re-parse funnel directly against the parent scope, because the
- * originating bundle may not match the target's level. The single-block route stays
- * synchronous through its mutation so the caller can set cursor state before the first
- * reactivity flush.
+ * Apply an inline paste, reporting where the caret lands in the stored bytes. A cross-block paste
+ * commits at the parent list, since the originating action bundle may not match the target's level.
  */
-export declare function applyInlineResult(targetPath: number[], result: InlinePasteResult, ctx: PasteDispatchContext): Promise<InlineCaretLanding | undefined>;
-export declare function applyStructuralResult(targetPath: number[], result: StructuralPasteResult, ctx: PasteDispatchContext, trailingSeparator?: string): Promise<void>;
+export declare function applyInlineResult(targetPath: number[], result: InlinePasteResult, ctx: PasteDispatchContext, start: CommitSnapshotArg): Promise<InlineCaretLanding | undefined>;
+export declare function applyStructuralResult(targetPath: number[], result: StructuralPasteResult, ctx: PasteDispatchContext, start: CommitSnapshotArg, trailingSeparator?: string): Promise<void>;

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

@@ -1,75 +1,45 @@
-/** Applies the results a paste surface hook produced to the document. */
-import { settledCaretTarget, updateNodeContent } from '../content-write';
-import { ensureUnsharedChild } from '../unshare';
-import { docPathFrom } from '../../cursor/coordinate-spaces';
-import { stampStructuralChange } from '../structural-change';
-import { resolveParentScope } from './parent-scope';
-import { replaceBlockAtParent } from './replace-block-at-parent';
+/** Applies the results a paste surface hook produced to the document. `start` is where the paste
+ *  began, which each commit records as undo's caret. */
+import { leafAtRawOffset } from '../container-offsets';
+import { blockNodeAt } from '../node-primitives';
 /**
- * Apply an inline paste. Single-block routes through `updateBlockContent`; cross-block
- * commits the same re-parse funnel directly against the parent scope, because the
- * originating bundle may not match the target's level. The single-block route stays
- * synchronous through its mutation so the caller can set cursor state before the first
- * reactivity flush.
+ * Apply an inline paste, reporting where the caret lands in the stored bytes. A cross-block paste
+ * commits at the parent list, since the originating action bundle may not match the target's level.
  */
-export async function applyInlineResult(targetPath, result, ctx) {
-    if (ctx.undoEntry === 'join') {
-        return commitInlineJoin(targetPath, result, ctx);
+export async function applyInlineResult(targetPath, result, ctx, start) {
+    if (ctx.crossBlock) {
+        return commitInlineCrossBlock(targetPath, result, ctx, start);
     }
-    // Unawaited: the caller sets pendingCursorOffset in the same synchronous block, so both
-    // land in one reactive flush.
+    // Unawaited, so the caller places the caret before the first reactive flush and both land in
+    // that one flush.
     const blockIndex = targetPath[targetPath.length - 1];
-    void ctx.blockEdit.updateBlockContent(blockIndex, result.newRaw, result.caretOffset);
-    return undefined;
+    const write = ctx.blockEdit.updateBlockContent(blockIndex, result.newRaw, 'literal', start.offset, result.caretOffset);
+    return write.admitted ? { path: targetPath, offset: write.caret } : undefined;
 }
 /**
- * Cross-block inline paste. `'join'` means the caller already pushed the covering
- * snapshot, not that the ceremony is skipped — committing is what keeps the parent's
- * `childIds` aligned and puts the insertion on the `edit` stream. The mutation routes
- * through the same-slot re-parse funnel, so a paste completing marker syntax re-mints the
- * slot at the reparsed kind instead of leaving the old kind holding foreign bytes.
+ * Cross-block inline paste, committed at the parent list so its `childIds` stay aligned. The write
+ * goes through the reparse path, so a paste that completes marker syntax changes the block's kind.
  */
-async function commitInlineJoin(targetPath, result, ctx) {
-    const scope = resolveParentScope(ctx.doc, targetPath, ctx.controller);
-    if (!scope)
-        return undefined;
-    const leafIndex = targetPath[targetPath.length - 1];
-    let settled = { change: { op: 'noop' }, textStart: 0 };
-    let siblings = [];
-    await ctx.controller.commitMultiScope({
-        scopes: [scope],
-        snapshot: 'skip',
-        mutate: ([view]) => {
-            // The slot may still be snapshot-shared, and the funnel's same-kind branch writes
-            // its raw in place (G1.9).
-            ensureUnsharedChild(view, leafIndex, view.sharing);
-            settled = updateNodeContent({ children: view.children, ownerKind: view.node.kind, owner: view.node }, leafIndex, result.newRaw, ctx.grammar, view.sharing);
-            siblings = view.children;
-            stampStructuralChange(view.children, settled.change, view.sharing);
-            return [settled.change];
-        },
-        op: {
-            kind: 'updateContent',
-            detail: { length: result.newRaw.length },
-            eventPath: docPathFrom(targetPath)
-        }
+async function commitInlineCrossBlock(targetPath, result, ctx, start) {
+    const landed = await ctx.controller.commitLeafText(targetPath, result.newRaw, {
+        caret: result.caretOffset,
+        snapshotOffset: start.offset
     });
-    // The paste can demote the slot's kind, and a settle that absorbed the join above it left
-    // the predecessor holding the pasted bytes — so the caller's own caret target is stale.
-    const target = settledCaretTarget(settled, leafIndex, result.caretOffset, siblings);
-    return { path: [...targetPath.slice(0, -1), target.index], offset: target.offset };
+    if (!landed.wrote)
+        return undefined;
+    // The paste can make the block a container, whose caret belongs in the leaf holding the offset.
+    const blockPath = [...landed.caret.path];
+    const block = blockNodeAt(ctx.doc, blockPath);
+    const leaf = block?.children?.length ? leafAtRawOffset(block, landed.caret.offset) : null;
+    return {
+        path: [...blockPath, ...(leaf?.path ?? [])],
+        offset: leaf?.offset ?? landed.caret.offset
+    };
 }
-export async function applyStructuralResult(targetPath, result, ctx, trailingSeparator = '') {
-    await replaceBlockAtParent({
-        doc: ctx.doc,
-        blockPath: targetPath,
-        replacement: result.replacement,
-        controller: ctx.controller,
-        undoEntry: ctx.undoEntry ?? 'own',
-        focusReplacementIndex: result.focusReplacementIndex,
-        focusOffset: result.focusOffset,
+export async function applyStructuralResult(targetPath, result, ctx, start, trailingSeparator = '') {
+    await ctx.controller.replaceBlock(targetPath, result.replacement, { replacementIndex: result.focusReplacementIndex, offset: result.focusOffset }, {
         source: 'paste-dispatch',
-        trailingSeparator,
-        ...(ctx.grammar ? { grammar: ctx.grammar } : {})
+        trailingBlank: trailingSeparator !== '',
+        snapshotOffset: start.offset
     });
 }