@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/tree-operations/list/sublist-separator.d.ts

@@ -1,13 +1,13 @@
 /**
- * The blank line a list whose first item is EMPTY owes the paragraph directly above it. A
- * content-less marker cannot interrupt a paragraph (CommonMark § 5.2), so those bytes reload as
- * a setext heading, and the marker is the item's only evidence, so the seam absorb has nothing
- * to fold it into. A content-bearing list that stopped interrupting is the absorb's case.
+ * The blank line a list whose first item is empty must have between it and the paragraph
+ * directly above: a marker with no content cannot interrupt a paragraph (CommonMark § 5.2), so
+ * without it those bytes reload as a setext heading.
  */
 import type { CstNode } from '../../core/nodes';
+/** Whether the child at `index` is a list no reload could read back where it stands. */
+export declare function lacksSublistSeparator(children: readonly CstNode[], index: number): boolean;
 /**
- * Give the child at `index` its separating line when it is a list no reload could read back.
- * Idempotent, and a no-op for every child that already stands apart, so a nesting splice or a
- * raw rebuild may call it unconditionally.
+ * Give the child at `index` its separating line when it is a list no reload could read back, so
+ * any splice or rebuild may call it unconditionally. The child must be owned by the live tree.
  */
 export declare function settleSublistSeparator(children: CstNode[], index: number): void;

package/dist/tree-operations/list/sublist-separator.js

@@ -1,34 +1,27 @@
 /**
- * The blank line a list whose first item is EMPTY owes the paragraph directly above it. A
- * content-less marker cannot interrupt a paragraph (CommonMark § 5.2), so those bytes reload as
- * a setext heading, and the marker is the item's only evidence, so the seam absorb has nothing
- * to fold it into. A content-bearing list that stopped interrupting is the absorb's case.
+ * The blank line a list whose first item is empty must have between it and the paragraph
+ * directly above: a marker with no content cannot interrupt a paragraph (CommonMark § 5.2), so
+ * without it those bytes reload as a setext heading.
  */
-import { trailingLineEnding } from '../../core/lines';
-/**
- * A marker line carrying nothing after it: the Enter+Tab mint, and an emptied nested item. The
- * trailing run is required, matching `matchListItem` — a bare `-` never opened a list at all.
- */
-const EMPTY_MARKER_LINE = /^ {0,3}(?:[-*+]|\d{1,9}[.)])[ \t]+$/;
-/**
- * Give the child at `index` its separating line when it is a list no reload could read back.
- * Idempotent, and a no-op for every child that already stands apart, so a nesting splice or a
- * raw rebuild may call it unconditionally.
- */
-export function settleSublistSeparator(children, index) {
+import { firstDisplayLine, isBlankText, ownTrailingLineEnding } from '../../core/lines';
+import { isContentlessItemLine } from '../../core/parsers/list';
+/** Whether the child at `index` is a list no reload could read back where it stands. */
+export function lacksSublistSeparator(children, index) {
     const list = children[index];
     const above = children[index - 1];
     if (!list || list.kind !== 'list' || list.leadingTrivia !== '')
-        return;
-    if (!above || above.kind !== 'paragraph' || above.raw.trim() === '')
-        return;
-    if (!EMPTY_MARKER_LINE.test(firstLineOf(list.raw)))
-        return;
-    list.leadingTrivia = trailingLineEnding(above.raw);
+        return false;
+    if (!above || above.kind !== 'paragraph' || isBlankText(above.raw))
+        return false;
+    return isContentlessItemLine(firstDisplayLine(list.raw).text);
 }
-function firstLineOf(raw) {
-    const nl = raw.indexOf('\n');
-    if (nl < 0)
-        return raw;
-    return raw[nl - 1] === '\r' ? raw.slice(0, nl - 1) : raw.slice(0, nl);
+/**
+ * Give the child at `index` its separating line when it is a list no reload could read back, so
+ * any splice or rebuild may call it unconditionally. The child must be owned by the live tree.
+ */
+export function settleSublistSeparator(children, index) {
+    if (!lacksSublistSeparator(children, index))
+        return;
+    // The paragraph above has the list below it, so it closes its line with the document's ending.
+    children[index].leadingTrivia = ownTrailingLineEnding(children[index - 1].raw);
 }

package/dist/tree-operations/list/task-paragraph.d.ts

@@ -0,0 +1,25 @@
+/**
+ * How one block's bytes read back in place. A task item's first paragraph starts right after the
+ * marker, so a write reads its text as the parser reads the item body (GFM task lists); a live
+ * rewrite's check reads a list item's first block behind its whole marker line. Everywhere else
+ * it is a plain fragment.
+ */
+import { type Document } from '../../core/nodes';
+import type { DocumentView, NodeView } from '../../core/node-views';
+import type { GrammarView } from '../../schema/block-openers';
+export type FragmentReader = (text: string) => Document;
+/** Whether the block at `index` under `owner` is the paragraph a task marker stands in front of. */
+export declare function followsTaskMarker(owner: NodeView | undefined, index: number): boolean;
+export declare function fragmentReaderAt(owner: NodeView | undefined, index: number, grammar: GrammarView): FragmentReader;
+/** `text` read as the list item `owner` reads its first block, behind its marker line; null when
+ *  that is not one item or changes its task state (a marker widened over a space is still one). */
+export declare function readThroughItemMarker(owner: NodeView, text: string, grammar: GrammarView): Document | null;
+/** A child slot: the block holding it (none at the document's top level) and its index there. */
+export interface ChildSlot {
+    owner: NodeView | undefined;
+    index: number;
+}
+/** The slot a document path names. */
+export declare function childSlotAt(doc: DocumentView, path: readonly number[]): ChildSlot;
+/** {@link fragmentReaderAt} for the slot a document path names. */
+export declare function slotReaderAt(doc: DocumentView, path: readonly number[], grammar: GrammarView): FragmentReader;

package/dist/tree-operations/list/task-paragraph.js

@@ -0,0 +1,54 @@
+/**
+ * How one block's bytes read back in place. A task item's first paragraph starts right after the
+ * marker, so a write reads its text as the parser reads the item body (GFM task lists); a live
+ * rewrite's check reads a list item's first block behind its whole marker line. Everywhere else
+ * it is a plain fragment.
+ */
+import { makeBlockNode, metadataOf } from '../../core/nodes';
+import { blockNodeAt } from '../node-primitives';
+import { readBlocks, parseTaskItemBody } from '../../core/parser';
+import { rebuildListItemRaw } from '../../schema/container-rebuilders';
+/** Whether the block at `index` under `owner` is the paragraph a task marker stands in front of. */
+export function followsTaskMarker(owner, index) {
+    return (index === 0 && owner?.kind === 'listItem' && metadataOf(owner, 'listItem')?.taskItem === true);
+}
+export function fragmentReaderAt(owner, index, grammar) {
+    // Fragment scope: these are one block's bytes, so a kind that depends on document position
+    // must not be produced here.
+    return followsTaskMarker(owner, index)
+        ? (text) => parseTaskItemBody(text, grammar)
+        : (text) => readBlocks(text, { grammar, scope: 'fragment' });
+}
+/** `text` read as the list item `owner` reads its first block, behind its marker line; null when
+ *  that is not one item or changes its task state (a marker widened over a space is still one). */
+export function readThroughItemMarker(owner, text, grammar) {
+    const meta = metadataOf(owner, 'listItem');
+    const probe = makeBlockNode({
+        kind: 'listItem',
+        leadingTrivia: '',
+        raw: '',
+        metadata: { ...meta },
+        children: [makeBlockNode({ kind: 'paragraph', leadingTrivia: '', raw: text })]
+    });
+    rebuildListItemRaw(probe);
+    const lists = readBlocks(probe.raw, { grammar, scope: 'fragment' }).children;
+    const items = lists.length === 1 && lists[0].kind === 'list' ? (lists[0].children ?? []) : [];
+    const item = items.length === 1 && items[0].kind === 'listItem' ? items[0] : null;
+    if (!item)
+        return null;
+    const read = metadataOf(item, 'listItem');
+    if (read.taskItem !== meta.taskItem || read.taskChecked !== meta.taskChecked)
+        return null;
+    return { kind: 'document', prefix: '', children: item.children ?? [], suffix: '' };
+}
+/** The slot a document path names. */
+export function childSlotAt(doc, path) {
+    const found = path.length > 1 ? blockNodeAt(doc, path.slice(0, -1)) : null;
+    const owner = found ?? undefined;
+    return { owner, index: path[path.length - 1] };
+}
+/** {@link fragmentReaderAt} for the slot a document path names. */
+export function slotReaderAt(doc, path, grammar) {
+    const { owner, index } = childSlotAt(doc, path);
+    return fragmentReaderAt(owner, index, grammar);
+}

package/dist/tree-operations/list/unwrap-merge.d.ts

@@ -1,27 +1,19 @@
 /**
- * Structural list-item reshaping for U1 (unwrap a list's first item) and M1 (merge a
- * non-first item into the deepest text leaf of the preceding item). Both preserve absolute
- * indent and keep ordered-marker sequences intact.
+ * Unwrapping a list's first item, and merging a later item into the deepest text leaf of the one
+ * before it. Both keep each block's absolute indent and the ordered-marker sequence.
  */
 import type { CstNode } from '../../core/nodes';
 import type { NodeView } from '../../core/node-views';
-import type { PresentationMode } from '../../presentation-mode';
-import type { InlineResolverRef } from '../../schema/inline-construct-policy';
+import type { Reading } from '../../schema/reading';
 import type { SharingState } from '../sharing';
 /**
- * Unwrap a list's first item (Rule U1) without mutating the input. Output order: the item's
- * non-promoting children lifted in place, then the shrunk parent list with the promoted
- * sub-list items prepended and ordered markers renumbered.
+ * Unwrap a list's first item without mutating the input: the item's other children lifted out,
+ * then the rest of the list with the promoted sub-list items first.
  */
 export declare function unwrapFirstItemFromList(list: NodeView): CstNode[];
-/**
- * Merge the list item at `currentIndex` into the deepest text-bearing leaf of the
- * preceding item, mutating `list` in place and returning the merge point for the caret.
- * `targetPath`'s trailing index is the LAST paragraph in the target item, not always 0.
- * Null when the previous item exposes only an opaque deepest leaf — that is a legitimate
- * outcome the caller falls back from, unlike a bad `currentIndex`, which throws.
- */
-export declare function mergeListItemIntoPrevious(list: CstNode, children: CstNode[], currentIndex: number, sharing: SharingState | undefined, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined): {
+/** Merge the item at `currentIndex` into the preceding item's last prose leaf, mutating `list`;
+ *  null when there is nothing to join, and the caller falls back. A bad `currentIndex` throws. */
+export declare function mergeListItemIntoPrevious(list: CstNode, children: CstNode[], currentIndex: number, sharing: SharingState | undefined, reading: Reading): {
     mergePoint: {
         targetPath: number[];
         offset: number;

package/dist/tree-operations/list/unwrap-merge.js

@@ -1,24 +1,22 @@
 /**
- * Structural list-item reshaping for U1 (unwrap a list's first item) and M1 (merge a
- * non-first item into the deepest text leaf of the preceding item). Both preserve absolute
- * indent and keep ordered-marker sequences intact.
+ * Unwrapping a list's first item, and merging a later item into the deepest text leaf of the one
+ * before it. Both keep each block's absolute indent and the ordered-marker sequence.
  */
 import { metadataOf } from '../../core/nodes';
 import { trailingLineEnding } from '../../core/lines';
-import { cleanJoinedRaw } from '../node-ops';
+import { joinIntoLeaf } from '../node-ops';
 import { cloneMetadata, cloneNode } from '../clone';
 import { rebuildAncestryRaw } from '../../schema/container-raw';
 import { rebuildListRaw } from '../../schema/container-rebuilders';
 import { walkToDeepestMergeLeaf } from '../../schema/merge-rules';
 import { orderedBaseOf, renumberOrderedList, renumberOrderedListFrom } from './ordered-markers';
 import { partitionItemChildren } from './item-partition';
-import { ensureUnsharedChild, ensureUnsharedNode, ensureUnsharedPath } from '../unshare';
+import { ensureUnsharedChild, ensureUnsharedNode } from '../unshare';
 import { assignIds } from '../../block-id';
 import { pushChild } from '../children';
 /**
- * Unwrap a list's first item (Rule U1) without mutating the input. Output order: the item's
- * non-promoting children lifted in place, then the shrunk parent list with the promoted
- * sub-list items prepended and ordered markers renumbered.
+ * Unwrap a list's first item without mutating the input: the item's other children lifted out,
+ * then the rest of the list with the promoted sub-list items first.
  */
 export function unwrapFirstItemFromList(list) {
     if (list.kind !== 'list' || !list.children || list.children.length === 0) {
@@ -27,7 +25,6 @@ export function unwrapFirstItemFromList(list) {
     const parentOrdered = metadataOf(list, 'list')?.ordered ?? false;
     const firstItem = list.children[0];
     if (!firstItem.children || firstItem.children.length === 0) {
-        // Empty item: nothing to lift, so return the shrunk list.
         const clonedList = cloneNode(list);
         const rest = clonedList.children.slice(1);
         if (rest.length === 0)
@@ -64,7 +61,7 @@ export function unwrapFirstItemFromList(list) {
     liftedBlocks.push(remainingList);
     return liftedBlocks;
 }
-/** M1's target-finder; null when no prose leaf is reachable. */
+/** The merge target's path; null when no prose leaf is reachable. */
 function findDeepestVisibleTextTarget(list, targetItemIndex) {
     if (!list.children || targetItemIndex < 0 || targetItemIndex >= list.children.length) {
         return null;
@@ -74,9 +71,8 @@ function findDeepestVisibleTextTarget(list, targetItemIndex) {
     return result ? result.path : null;
 }
 /**
- * The depth-1 sibling list that "preserve absolute indent" promotes into: the last list
- * child of the merge target's top-level item, only when the target sits deep enough
- * (path length >= 4). Unshares the list it resolves.
+ * The last list child of the merge target's top-level item, where a deep target's nested items
+ * go to keep their indent. Unshares the list it resolves.
  */
 function depthOneListFor(list, targetPath, sharing) {
     if (targetPath.length < 4)
@@ -93,13 +89,10 @@ function depthOneListFor(list, targetPath, sharing) {
     return depthOneList.children ? depthOneList : null;
 }
 /**
- * Relocate the merged-away item's remaining children by "preserve absolute indent":
- * nested-list items promote to the depth-1 sibling container when the merge target sits
- * deeper, everything else absorbs into the target item. Children are MOVED into the live
- * tree and unshared individually, so the snapshot's view of the deleted item stays intact
- * (G1.9).
+ * Move the merged item's remaining children to where they keep their absolute indent, copying each
+ * first so the undo entry's deleted item stays intact.
  */
-function relocateRemainingChildren(list, targetPath, targetItem, currentItem, lineEnding, sharing) {
+function relocateRemainingChildren(list, targetPath, targetItem, currentItem, sharing) {
     const remainingChildren = currentItem
         .children.slice(1)
         .map((c) => (sharing ? ensureUnsharedNode(c, sharing) : c));
@@ -110,93 +103,65 @@ function relocateRemainingChildren(list, targetPath, targetItem, currentItem, li
                 for (let i = 0; i < child.children.length; i++) {
                     const item = sharing ? ensureUnsharedChild(child, i, sharing) : child.children[i];
                     item.leadingTrivia = '';
-                    // discovered-descendant mutation, see node-primitives.ts header
+                    // An in-place write on a descendant found by walking, see the `node-primitives.ts` header.
                     pushChild(depthOneList, item);
                 }
                 rebuildListRaw(depthOneList);
                 continue;
             }
-            // discovered-descendant mutation, see node-primitives.ts header
+            // An in-place write on a descendant found by walking, see the `node-primitives.ts` header.
             pushChild(targetItem, child);
         }
         else {
-            // A trailing paragraph keeps its blank-line separator, or the two lazy-continue
-            // into one on reload. Other leaves start fresh and need none.
-            child.leadingTrivia = child.kind === 'paragraph' ? lineEnding : '';
-            // discovered-descendant mutation, see node-primitives.ts header
+            // The child keeps its own blank line: the joined text above it ends the way the text it
+            // followed did. An in-place write on a descendant, see the `node-primitives.ts` header.
             pushChild(targetItem, child);
         }
     }
 }
-/**
- * Merge the list item at `currentIndex` into the deepest text-bearing leaf of the
- * preceding item, mutating `list` in place and returning the merge point for the caret.
- * `targetPath`'s trailing index is the LAST paragraph in the target item, not always 0.
- * Null when the previous item exposes only an opaque deepest leaf — that is a legitimate
- * outcome the caller falls back from, unlike a bad `currentIndex`, which throws.
- */
-export function mergeListItemIntoPrevious(list, children, currentIndex, sharing, presentationMode, linkRef) {
-    // Targeting may read `list.children`, but the final splice MUST land in `children`
-    // (`node-ops.ts` header).
+/** Merge the item at `currentIndex` into the preceding item's last prose leaf, mutating `list`;
+ *  null when there is nothing to join, and the caller falls back. A bad `currentIndex` throws. */
+export function mergeListItemIntoPrevious(list, children, currentIndex, sharing, reading) {
+    // Targeting may read `list.children`, but the final splice must land in `children`
+    // (`node-primitives.ts` header).
     if (list.kind !== 'list' ||
         !list.children ||
         currentIndex <= 0 ||
         currentIndex >= children.length) {
         throw new Error(`mergeListItemIntoPrevious: invalid currentIndex ${currentIndex}`);
     }
-    const previousIndex = currentIndex - 1;
-    const targetPath = findDeepestVisibleTextTarget(list, previousIndex);
+    const targetPath = findDeepestVisibleTextTarget(list, currentIndex - 1);
     if (!targetPath)
         return null;
-    // Before any capture: the walk below must see the owned copies, and the target
-    // paragraph's raw is written in place.
-    if (sharing)
-        ensureUnsharedPath({ children: list.children }, targetPath, sharing);
-    let targetItem = list;
-    for (let i = 0; i < targetPath.length - 1; i++) {
-        targetItem = targetItem.children[targetPath[i]];
-    }
-    // A loose item's walker ends past 0, so reading children[0] would mutate the wrong
-    // paragraph.
-    const targetParagraphIndex = targetPath[targetPath.length - 1];
-    const targetParagraph = targetItem.children?.[targetParagraphIndex];
-    if (!targetParagraph || targetParagraph.kind !== 'paragraph') {
-        throw new Error('mergeListItemIntoPrevious: target path does not end at a paragraph');
-    }
-    const targetOriginalText = (targetParagraph.raw ?? '').replace(/\r?\n$/, '');
     const currentItem = children[currentIndex];
-    if (!currentItem.children ||
-        currentItem.children.length === 0 ||
-        currentItem.children[0].kind !== 'paragraph') {
-        throw new Error('mergeListItemIntoPrevious: current item does not start with a paragraph');
-    }
-    const currentFirstParagraph = currentItem.children[0];
-    const currentFirstText = (currentFirstParagraph.raw ?? '').replace(/\r?\n$/, '');
-    const lineEnding = trailingLineEnding(targetParagraph.raw ?? '');
-    // Every destructive join crosses the seam cleaner, M1 included: a literal concatenation
-    // surfaces the marker runs the join orphaned, which live paints for nobody.
-    const joined = cleanJoinedRaw({
-        mergedRaw: targetOriginalText + currentFirstText,
-        seam: targetOriginalText.length,
-        start: { node: targetParagraph, offset: targetOriginalText.length },
-        end: { node: currentFirstParagraph, offset: 0 },
-        linkRef
-    }, presentationMode);
-    // The caret rides the CLEANED seam: a run dropped on the target's side moves where the
-    // two halves met.
-    const mergeOffset = joined.seam;
-    targetParagraph.raw = joined.raw + lineEnding;
-    relocateRemainingChildren(list, targetPath, targetItem, currentItem, lineEnding, sharing);
+    const absorbed = currentItem.children?.[0];
+    if (absorbed?.kind !== 'paragraph')
+        return null;
+    // The target has the current item below it, so it closes its line with the document's ending.
+    const lineEnding = trailingLineEnding(nodeAt(list, targetPath).raw, '\n');
+    const body = { children: list.children, owner: list, lineEnding };
+    const joined = joinIntoLeaf(body, targetPath, absorbed, reading, sharing);
+    if (!joined)
+        return null;
+    const targetItem = nodeAt(list, targetPath.slice(0, -1));
+    relocateRemainingChildren(list, targetPath, targetItem, currentItem, sharing);
     children.splice(currentIndex, 1);
     // So the post-splice reads below see the new shape; idempotent with the commit's
-    // final publish.
+    // final write to state.
     list.children = children;
-    rebuildAncestryRaw(list, targetPath);
+    rebuildAncestryRaw(list, targetPath, reading.grammar);
     if (metadataOf(list, 'list')?.ordered) {
-        // M1 only removes a non-first item, so children[0] keeps the list's original base;
+        // The merge only removes a non-first item, so children[0] keeps the list's starting number;
         // renumber from 1 to continue it rather than resetting the sequence.
         renumberOrderedList(list, 1, sharing);
         rebuildListRaw(list);
     }
-    return { mergePoint: { targetPath, offset: mergeOffset } };
+    return { mergePoint: { targetPath, offset: joined.joinOffset } };
+}
+/** The node at `path` below `root`, re-read through the tree. */
+function nodeAt(root, path) {
+    let node = root;
+    for (const index of path)
+        node = node.children[index];
+    return node;
 }

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

@@ -1,79 +1,57 @@
 /**
- * The split and merge primitives, the two ops that re-tile a body's blocks around a caret, plus
- * the join cleanup every destructive join crosses (live-mode.md § 4.5). They mutate and report;
- * the settle around them is the ceremony's (`settle.ts`).
+ * Split and merge, the two operations that re-divide a body's blocks around a caret. They mutate
+ * and report; the commit recomputes the separators around them.
  */
-import { type CstNode } from '../core/nodes';
+import type { CstNode } from '../core/nodes';
 import type { NodeView } from '../core/node-views';
-import type { GrammarView } from '../schema/block-openers';
-import { type CleanedJoin, type InlineResolverRef, type JoinSeam } from '../schema/inline-construct-policy';
-import type { PresentationMode } from '../presentation-mode';
+import type { Reading } from '../schema/reading';
 import type { SharingState } from './sharing';
 import { type StructuralChange } from './structural-change';
-import { type BodyParentArg, type NodeParent } from './node-primitives';
-/** What a split leaves the caret: the structural splice, plus where the second half's head
- *  landed, past `blockIndex + 1` when the first half reparsed to several blocks. */
+import { type BodyParentArg } from './node-primitives';
+import { type FragmentReader } from './list/task-paragraph';
+/** What a split reports: the structural splice, plus where the second half's head ended up,
+ *  past `blockIndex + 1` when the first half reparsed to several blocks. */
 export interface SplitResult {
     change: StructuralChange;
     secondHalfIndex: number;
 }
 /**
- * The landing a site is about to consume, held to the primitive's answer (G1.34): a re-derived
- * `blockIndex + 1` warns instead of shipping.
- */
-export declare function assertSplitLanding(split: SplitResult, landing: number): void;
-/**
- * What a one-slot sink is about to put in its slot, held to one node (G1.35). Asked at the WRITE
- * with the nodes being written, so the guard answers for sink N+1.
+ * A write target that holds one block must receive exactly one; checking at the write means a
+ * new write target inherits the check (G1.35).
  */
 export declare function assertSingleNodeSink(sink: string, installed: readonly CstNode[]): void;
 /**
- * Split the node at `blockIndex` at raw `offset` (display-relative). The first half inherits the
- * original ID and the whole structural suffix (a setext underline); the second half opens with a
- * blank separator wherever one does structural work ({@link separatorSplitsOffNextLine}).
+ * Split the node at `blockIndex` at `offset`; the first half keeps the ID and any setext underline.
+ * A caller moving the second half elsewhere passes `readSecondHalf` for that position.
  */
-export declare function splitNode(parent: BodyParentArg, blockIndex: number, offset: number, sharing: SharingState | undefined, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined): SplitResult;
-/**
- * `join.mergedRaw` with the delimiter runs the join orphaned at its seam dropped, live only
- * (live-mode.md § 4.5). The one registered cleaner verifies its own bytes and otherwise declines,
- * leaving the literal join every other mode gets. Every destructive join crosses this door.
- */
-export declare function cleanJoinedRaw(join: JoinSeam, presentationMode: PresentationMode | undefined): CleanedJoin;
-/**
- * The bytes a single-block edit leaves when it deletes `range` out of `display`. A delete-then-
- * insert is a join like any other, so it crosses the same cleanup, and the returned offset is
- * where the two sides now meet.
- */
-export declare function cutRangeFromDisplay(node: NodeView, display: string, range: {
-    start: number;
-    end: number;
-}, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined): {
-    display: string;
-    offset: number;
-};
-/** What a join leaves the caret: the structural splice, plus where the two blocks met in the
- *  survivor's bytes, which a seam cleanup moves when it drops a run on the first block's side. */
+export declare function splitNode(parent: BodyParentArg, blockIndex: number, offset: number, sharing: SharingState | undefined, reading: Reading, readSecondHalf?: FragmentReader): SplitResult;
+/** What a join reports: the structural splice, plus where the two blocks met in the survivor's
+ *  bytes, which the join cleanup moves when it drops a run on the first block's side. */
 export interface MergeResult {
     change: StructuralChange;
     joinOffset: number;
 }
-/**
- * `targetPath` is relative to `parent.children[blockIndex - 1]`: empty means prev itself
- * is the leaf, non-empty walks into prev's container subtree.
- */
+/** Where the join landed: the block at `index` in the parent, and the leaf at `targetPath` below
+ *  it (empty when that block is the leaf). The index is `blockIndex - 1` unless the fix-up after
+ *  the delete merged that block into the one above it. */
 export interface MergeIntoPrevResult {
+    index: number;
     targetPath: number[];
     joinOffset: number;
     change: StructuralChange;
 }
+/** Join `absorbed`'s text onto the end of the leaf at `path`, leaving `absorbed` for the caller to
+ *  remove; null, writing nothing, when the joined bytes read as several blocks. */
+export declare function joinIntoLeaf(parent: BodyParentArg, path: readonly number[], absorbed: NodeView, reading: Reading, sharing: SharingState | undefined): {
+    joinOffset: number;
+} | null;
 /**
- * Merge `curr` into the deepest prose leaf of `prev`, writing into that leaf rather than
- * reparsing concatenated raw, which preserves prev's component identity and IME state. Null when
- * no mergeable leaf exists, so the caller can fall back to move-focus.
+ * Merge `curr` into `prev`'s deepest prose leaf, writing into the leaf so it keeps its component
+ * and IME state. Null when no leaf can take it, so the caller moves focus instead.
  */
-export declare function mergeIntoPrevDeepLeaf(parent: BodyParentArg, blockIndex: number, sharing: SharingState | undefined, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined, grammar?: GrammarView): MergeIntoPrevResult | null;
+export declare function mergeIntoPrevDeepLeaf(parent: BodyParentArg, blockIndex: number, sharing: SharingState | undefined, reading: Reading): MergeIntoPrevResult | null;
 /**
- * Merge the node at `blockIndex` with its successor; combined raw is re-parsed and the
- * merged block inherits the current block's ID. Noop at the tail.
+ * Merge the node at `blockIndex` with its successor through {@link joinIntoLeaf}, then remove the
+ * successor. The merged block keeps the current block's ID. Noop at the tail or on a refused join.
  */
-export declare function mergeWithNext(parent: NodeParent, blockIndex: number, presentationMode: PresentationMode | undefined, linkRef: InlineResolverRef | undefined): MergeResult;
+export declare function mergeWithNext(parent: BodyParentArg, blockIndex: number, reading: Reading, sharing: SharingState | undefined): MergeResult;