@voithos-labs/aragonite 0.10.2 → 0.10.3

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

@@ -0,0 +1,75 @@
+/**
+ * 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`.
+ */
+import type { AnyBlockKind, CstNode, Document } from '../core/nodes';
+import type { DocumentView, NodeView } from '../core/node-views';
+import type { GrammarView } from '../schema/block-openers';
+/** 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.
+ */
+export type BodyParent = NodeParent & {
+    ownerKind: AnyBlockKind | undefined;
+    owner: CstNode | undefined;
+    suffix?: string;
+};
+/** What the byte sinks accept: a whole `Document` IS the answer (the root owns no body grammar). */
+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.
+ */
+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. */
+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.
+ */
+export declare function normalizeOwnRaw(node: NodeView, raw: string): 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}.
+ */
+export declare function writeOwnRaw(node: CstNode, raw: string, grammar: GrammarView | undefined): 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).
+ */
+export declare function paragraphNode(leadingTrivia: string, text: string, lineEnding: string): CstNode;
+/** The empty-paragraph placeholder keeping an emptied document or container caret-addressable. */
+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;
+/** `nodeAt` pre-narrowed through `isBlockNode`: null at the document root or on no match. */
+export declare function blockNodeAt(doc: Document, path: number[]): CstNode | null;
+export declare function blockNodeAt(doc: DocumentView, path: number[]): NodeView | null;
+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.
+ */
+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;

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

@@ -0,0 +1,117 @@
+/**
+ * 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`.
+ */
+import { parse } from '../core/parser';
+import { trailingLineEnding } from '../core/lines';
+import { getBlockKindDescriptor, 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;
+}
+/** {@link normalizeBodyWrite} for a sink holding the parent rather than the owner's kind. */
+export const forBody = (parent, raw) => normalizeBodyWrite(ownerKindOf(parent), raw);
+/**
+ * `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.
+ */
+export function normalizeOwnRaw(node, raw) {
+    return tryGetBlockKindDescriptor(node.kind)?.normalizeRawWrite?.(raw, node) ?? raw;
+}
+/**
+ * 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}.
+ */
+export function writeOwnRaw(node, raw, grammar) {
+    const descriptor = tryGetBlockKindDescriptor(node.kind);
+    const legal = descriptor?.normalizeRawWrite?.(raw, node) ?? raw;
+    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)
+        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;
+}
+// ── Node minting ──
+/**
+ * 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).
+ */
+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. */
+export function emptyParagraph(leadingTrivia, lineEnding) {
+    return paragraphNode(leadingTrivia, '', lineEnding);
+}
+export function nodeAt(doc, path) {
+    let cur = doc;
+    for (const idx of path) {
+        if (!cur.children || idx < 0 || idx >= cur.children.length)
+            return null;
+        cur = cur.children[idx];
+    }
+    return cur;
+}
+export function blockNodeAt(doc, path) {
+    const node = nodeAt(doc, path);
+    return node !== null && isBlockNode(node) ? node : null;
+}
+export function isBlockNode(node) {
+    return 'raw' in 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.
+ */
+export const NEXT_PROSE_LINE = 'x';
+/** First node inherits the original block's leadingTrivia; subsequent nodes keep theirs. */
+export function normalizeReplacementTrivia(original, replacement) {
+    const originalTrivia = original.leadingTrivia ?? '';
+    return replacement.map((node, i) => {
+        const copy = { ...node };
+        copy.leadingTrivia = i === 0 ? originalTrivia : (copy.leadingTrivia ?? '');
+        return copy;
+    });
+}
+// ── 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')
+        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);
+        }
+    }
+}

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

@@ -1,5 +1,5 @@
 /** Applies the results a paste surface hook produced to the document. */
-import { settledCaretTarget, updateNodeContent } from '../node-ops';
+import { settledCaretTarget, updateNodeContent } from '../content-write';
 import { ensureUnsharedChild } from '../unshare';
 import { docPathFrom } from '../../cursor/coordinate-spaces';
 import { stampStructuralChange } from '../structural-change';

package/dist/tree-operations/paste/body-write.d.ts

@@ -1,6 +1,6 @@
 /**
  * The paste family's `bodyWrite` moment: paste builds nodes upstream of every
- * node-ops byte sink, so a container's escape lands here instead — on the clipboard text
+ * content-write byte sink, so a container's escape lands here instead — on the clipboard text
  * ahead of the strategy-picking parse, and on the built replacement at the splice.
  */
 import type { AnyBlockKind, CstNode, Document } from '../../core/nodes';

package/dist/tree-operations/paste/body-write.js

@@ -1,11 +1,11 @@
 /**
  * The paste family's `bodyWrite` moment: paste builds nodes upstream of every
- * node-ops byte sink, so a container's escape lands here instead — on the clipboard text
+ * content-write byte sink, so a container's escape lands here instead — on the clipboard text
  * ahead of the strategy-picking parse, and on the built replacement at the splice.
  */
 import { parse } from '../../core/parser';
 import { tryGetBlockKindDescriptor } from '../../schema/block-kind-descriptor';
-import { ensureEditableContainers, isBlockNode, nodeAt, normalizeBodyWrite, normalizeReplacementTrivia } from '../node-ops';
+import { ensureEditableContainers, isBlockNode, nodeAt, normalizeBodyWrite, normalizeReplacementTrivia } from '../node-primitives';
 /** Clipboard text made legal inside every `bodyWrite`-declaring ancestor of the paste target. */
 export function normalizeClipboardForBody(doc, targetPath, text) {
     let out = text;

package/dist/tree-operations/paste/container-match.js

@@ -6,10 +6,12 @@
 import { CURSOR_END } from '../../block-component';
 import { devWarn } from '../../dev-warn';
 import { trailingLineEnding, trimTrailingLineEnding } from '../../core/lines';
-import { nodeAt, settledCaretTarget, updateNodeContent, writeOwnRaw } from '../node-ops';
+import { nodeAt, writeOwnRaw } from '../node-primitives';
+import { settledCaretTarget, updateNodeContent } from '../content-write';
 import { containerPasteFor } from './container-paste';
 import { rebuildContainerRawIfContainer } from '../../schema/container-raw';
-import { ensureUnsharedNode, ensureUnsharedPath, rebuildUnsharedChain } from '../unshare';
+import { ensureUnsharedNode, ensureUnsharedPath } from '../unshare';
+import { rebuildUnsharedChain } from '../chain-rebuild';
 import { containerScopeState } from './parent-scope';
 import { applyStructuralChangeToIdsRefs, stampStructuralChange } from '../structural-change';
 import { renumberOrderedList, templatePastedItemMarkers } from '../list/ordered-markers';

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

@@ -6,7 +6,8 @@
  * block's `pendingCursorOffset` may address a block the range delete is about to unmount.
  */
 import { parse } from '../../core/parser';
-import { cutRangeFromDisplay, isBlockNode, nodeAt } from '../node-ops';
+import { isBlockNode, nodeAt } from '../node-primitives';
+import { cutRangeFromDisplay } from '../node-ops';
 import { trailingLineEnding, trimTrailingLineEnding } from '../../core/lines';
 import { getPasteSurface } from '../paste-surfaces';
 import { isReservedChromeChild } from '../../schema/reserved-chrome';

package/dist/tree-operations/paste/find-enclosing-list.js

@@ -1,4 +1,4 @@
-import { nodeAt } from '../node-ops';
+import { nodeAt } from '../node-primitives';
 /** Returns null when no list ancestor exists or the target isn't a direct leaf of a listItem. */
 export function findEnclosingListForPaste(doc, targetPath) {
     if (targetPath.length < 3)

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

@@ -5,7 +5,7 @@
  */
 import type { CstNode } from '../../core/nodes';
 import type { NodeView } from '../../core/node-views';
-import type { TrackedPosition } from '../node-ops';
+import type { TrackedPosition } from '../settle';
 /**
  * Focus index for the replacement: the last PASTED node. Single-sourced so every structural
  * route skips the reattached residue identically. Applies only where the residue is a SEPARATE

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

@@ -7,7 +7,7 @@
  */
 import { CURSOR_END } from '../../block-component';
 import { metadataOf } from '../../core/nodes';
-import { nodeAt, ensureEditableContainers } from '../node-ops';
+import { nodeAt, ensureEditableContainers } from '../node-primitives';
 import { cloneNode } from '../clone';
 import { containerPasteFor } from './container-paste';
 import { stampStructuralChange } from '../structural-change';

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

@@ -4,7 +4,7 @@
  * semantic type. Same-type pastes go through `list-absorb`.
  */
 import { CURSOR_END } from '../../block-component';
-import { nodeAt, ensureEditableContainers } from '../node-ops';
+import { nodeAt, ensureEditableContainers } from '../node-primitives';
 import { cloneNode } from '../clone';
 import { spliceMany } from '../splice-many';
 import { stampStructuralChange } from '../structural-change';

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

@@ -4,7 +4,7 @@
  * scope — a caller holding a nested-bundle blockEdit would misroute through the wrong
  * container.
  */
-import { nodeAt } from '../node-ops';
+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) {

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

@@ -5,7 +5,7 @@
  */
 import { snapToScalarBoundary, trailingLineEnding, trimTrailingLineEnding } from '../../core/lines';
 import { isBlankParagraph } from '../../core/parser';
-import { ensureEditableContainers } from '../node-ops';
+import { ensureEditableContainers } from '../node-primitives';
 import { parseFirstBlock } from '../parse-block';
 export function buildPastedReplacement(leaf, offset, blocks) {
     if (blocks.length === 0)

package/dist/tree-operations/paste/replace-block-at-parent.js

@@ -3,7 +3,7 @@
  * rather than through the caller's blockEdit — paste-into-cell must mutate `doc.children`
  * while holding the row-level nested bundle.
  */
-import { nodeAt } from '../node-ops';
+import { nodeAt } from '../node-primitives';
 import { spliceMany } from '../splice-many';
 import { trailingLineEnding } from '../../core/lines';
 import { normalizeReplacementForBody } from './body-write';

package/dist/tree-operations/path-mutate.d.ts

@@ -1,6 +1,6 @@
 /**
  * Path-addressed child splices for the range-delete ceremony. Both route through
- * `spliceChildrenSettled` (`node-ops.ts`): they address containers at arbitrary depth, which is
+ * `spliceChildrenSettled` (`settle.ts`): they address containers at arbitrary depth, which is
  * exactly where a desynced `childIds` or an unsettled separator becomes permanent. `sharing` is
  * REQUIRED, not optional: the settle writes the surviving neighbours' own bytes, so a door
  * reached without it writes through a snapshot-shared node (G1.9). Callers unshare the PARENT

package/dist/tree-operations/path-mutate.js

@@ -1,4 +1,5 @@
-import { nodeAt, spliceChildrenSettled } from './node-ops';
+import { nodeAt } from './node-primitives';
+import { spliceChildrenSettled } from './settle';
 export function deleteAtPath(doc, path, sharing) {
     if (path.length === 0)
         return;

package/dist/tree-operations/reorder-unit.js

@@ -6,7 +6,7 @@
  * than walking past to the document and teleporting the container to a top-level index.
  */
 import { tryGetBlockKindDescriptor } from '../schema/block-kind-descriptor';
-import { nodeAt } from './node-ops';
+import { nodeAt } from './node-primitives';
 export function resolveReorderUnit(doc, path) {
     for (let depth = path.length; depth >= 1; depth--) {
         const parentPath = path.slice(0, depth - 1);

package/dist/tree-operations/reorder.d.ts

@@ -1,6 +1,6 @@
 import type { CstNode } from '../core/nodes';
 import type { SharingState } from './sharing';
-import { type SettledSplice } from './node-ops';
+import { type SettledSplice } from './settle';
 import type { StructuralChange } from './structural-change';
 export declare function reorderChildren(children: CstNode[], from: number, to: number): StructuralChange;
 /**
@@ -10,4 +10,7 @@ export declare function reorderChildren(children: CstNode[], from: number, to: n
  * already be an owned array. The landing rides the result: a fold settling a seam the move
  * invalidated can sit above the moved block.
  */
-export declare function reorderChildrenWithTrivia(children: CstNode[], from: number, to: number, sharing: SharingState): SettledSplice;
+export declare function reorderChildrenWithTrivia(children: CstNode[], from: number, to: number, sharing: SharingState, 
+/** Top-level blocks only: a blank line is a document separator, not a list's or a quote's,
+ *  whose own children carry their marker and would read a bare blank line as an end. */
+separators?: boolean): SettledSplice;

package/dist/tree-operations/reorder.js

@@ -1,5 +1,7 @@
+import { isBlankParagraph, parse } from '../core/parser';
+import { trailingLineEnding } from '../core/lines';
 import { ensureUnsharedChild } from './unshare';
-import { absorbWindowSeams } from './node-ops';
+import { absorbWindowSeams, settleSeparatorOnBlank } from './settle';
 import { devWarn } from '../dev-warn';
 // A stale index (a mid-drag delete shrank the array) would splice `undefined` into the
 // $state tree, so both entry points bail through this BEFORE any unshare or write.
@@ -37,7 +39,10 @@ export function reorderChildren(children, from, to) {
  * already be an owned array. The landing rides the result: a fold settling a seam the move
  * invalidated can sit above the moved block.
  */
-export function reorderChildrenWithTrivia(children, from, to, sharing) {
+export function reorderChildrenWithTrivia(children, from, to, sharing, 
+/** Top-level blocks only: a blank line is a document separator, not a list's or a quote's,
+ *  whose own children carry their marker and would read a bare blank line as an end. */
+separators = false) {
     if (from === to)
         return { change: { op: 'noop' }, landing: to };
     if (isReorderOutOfBounds(from, to, children.length)) {
@@ -53,5 +58,53 @@ export function reorderChildrenWithTrivia(children, from, to, sharing) {
     for (let k = 0; k < windowTrivia.length; k++) {
         children[lo + k].leadingTrivia = windowTrivia[k];
     }
+    if (separators) {
+        // The rotation reseats every slot in the window, and a block can land flush under a
+        // paragraph that then reads its lines as its own (a table dissolving into the prose above
+        // it). The seam it VACATED is the exception: a pair rejoining once the block between them
+        // leaves is the reload's own reading, which the absorber below settles.
+        const vacated = from < to ? from : from + 1;
+        for (let at = lo; at <= hi + 1; at++) {
+            if (at !== vacated)
+                separateSeam(children, at, sharing);
+        }
+        // A blank line reseated by position can hold a line its follower holds too; the run owes
+        // exactly one, and none at the document head, where the reload reads each as a block.
+        for (let at = lo; at <= hi; at++) {
+            if (isBlankParagraph(children[at]))
+                settleSeparatorOnBlank({ children }, at, sharing);
+        }
+    }
     return absorbWindowSeams({ children }, lo, hi - lo + 1, to, change, sharing);
 }
+/**
+ * Give the follower at `at` a separator where the reload would otherwise not read the two
+ * blocks back as themselves, and only then: a block that swallows across a blank line (an
+ * unterminated fence taking the prose below it) is the reload's true reading, left to the
+ * absorber, which the fold tests pin.
+ */
+function separateSeam(children, at, sharing) {
+    if (at <= 0 || at >= children.length)
+        return;
+    const prev = children[at - 1];
+    const next = children[at];
+    const apart = withLeadingLine(next.leadingTrivia, trailingLineEnding(next.raw));
+    if (apart === next.leadingTrivia)
+        return;
+    if (readsAsBoth(prev, next.leadingTrivia, next) || !readsAsBoth(prev, apart, next))
+        return;
+    ensureUnsharedChild({ children }, at, sharing).leadingTrivia = apart;
+}
+function withLeadingLine(trivia, eol) {
+    return trivia.startsWith('\n') || trivia.startsWith('\r\n') ? trivia : eol + trivia;
+}
+// Two blocks of the same shape, not merely two: a quote lazily taking the first line of the
+// prose below it still reads as two, with the remainder a different kind.
+function readsAsBoth(prev, trivia, next) {
+    const blocks = parse(prev.raw + trivia + next.raw, { scope: 'fragment' }).children;
+    return (blocks.length === 2 &&
+        blocks[0].kind === prev.kind &&
+        blocks[0].raw === prev.raw &&
+        blocks[1].kind === next.kind &&
+        blocks[1].raw === next.raw);
+}

package/dist/tree-operations/settle.d.ts

@@ -0,0 +1,105 @@
+/**
+ * The separator settle every splice owes its neighbourhood (syntax-tree.md § Blank lines), the
+ * seam absorb behind it (editor.md § 8), and the delete primitive built on both. `sharing` owns
+ * every in-place write (G1.9); the retire census in `lint/separator-write-doors.test.ts` names
+ * every door here.
+ */
+import type { CstNode, Document } from '../core/nodes';
+import type { NodeView } from '../core/node-views';
+import type { SharingState } from './sharing';
+import { type StructuralChange } from './structural-change';
+import { type BodyParentArg, type NodeParent, type SeparatorParent } from './node-primitives';
+/**
+ * Settle the separator at `index`: nothing needs one at the body head or below a blank block,
+ * where the parser would read the extra line as one more empty paragraph.
+ */
+export declare function clearRedundantSeparator(parent: SeparatorParent, index: number, sharing?: SharingState): void;
+/**
+ * A blank block IS a blank line, so it and its follower share ONE separator (G2.13). The
+ * follower's stands, so a later fill of this slot still finds the follower separated.
+ */
+export declare function dropDoubledSeparator(parent: SeparatorParent, index: number, sharing?: SharingState): void;
+/**
+ * The separator a block takes back when it stops being blank: its own blank line was what stood
+ * between it and a non-blank predecessor. Call at the fill.
+ */
+export declare function restoreSeparatorOnFill(parent: SeparatorParent, index: number, sharing?: SharingState): void;
+/**
+ * The separator the block BELOW a consumed blank line takes back: the same mint minus the
+ * blank-self guard, declined where its own follower already holds one (G2.13).
+ */
+export declare function restoreSeparatorAfterBlank(parent: SeparatorParent, index: number, sharing?: SharingState): void;
+/**
+ * The settle a block turning INTO a blank line owes: the run it joins carries exactly ONE
+ * separating line across every block in it AND its follower. The line already standing is
+ * kept; a mint lands at the run's head, the only slot one may take.
+ */
+export declare function settleSeparatorOnBlank(parent: SeparatorParent, index: number, sharing?: SharingState): void;
+/**
+ * The give-back twin of {@link settleSeparatorOnBlank}'s closer peel: a tail that stops being
+ * blank owes the borrowed `innerSuffix` line back, or the wrap emits a line nobody typed.
+ */
+export declare function releaseWrapPeel(parent: SeparatorParent, index: number): void;
+/**
+ * The commit ceremony's settle door: derive the spliced window from the change and settle it
+ * against `before`, the pre-mutate children. Nodes surviving inside the window are not removals,
+ * so a coarse descriptor over an in-place write settles as one.
+ */
+export declare function settleSeparator(parent: SeparatorParent, before: readonly CstNode[], change: StructuralChange, sharing?: SharingState, tracked?: TrackedPosition): StructuralChange;
+/**
+ * The out-of-commit-scope twin of {@link settleSeparator}, for a container discovered by walking
+ * the live tree: it splices through the `childIds` door and reads the pre-splice span itself.
+ */
+export declare function spliceChildrenSettled(parent: CstNode | Document, at: number, removeCount: number, replacement: CstNode[], sharing?: SharingState): void;
+/**
+ * What a seam settle absorbed: post-splice window position and size, and the net blocks eaten.
+ * `span + eaten` is the pre-absorb slot count, which is what a change descriptor reports.
+ */
+interface SeamAbsorption {
+    at: number;
+    span: number;
+    eaten: number;
+    spliced: boolean;
+}
+/** A byte position the folds carry with them, written in place since each fold re-tiles the bytes. */
+export interface TrackedPosition {
+    index: number;
+    offset: number;
+}
+/**
+ * A splice can leave neighbours whose adjacent bytes re-read as fewer blocks on reload. Absorb
+ * while the window's own bytes parse to fewer blocks, which is the reload's reading; a blank run
+ * is transparent to a container's continuation, so the window anchors at the nearest non-blank
+ * block above the seam, never below `floor`, and cascades.
+ */
+export declare function absorbSeamReading(parent: NodeParent, seamLeft: number, floor: number, sharing?: SharingState, tracked?: TrackedPosition, headProbe?: number, onBeforeSplice?: () => void): SeamAbsorption;
+/**
+ * Map a post-edit caret offset (in the committed text) to the parsed block it falls in, as a
+ * local display offset. An offset inside inter-block trivia lands at the next block's start;
+ * past-the-end clamps to the last.
+ */
+export declare function focusTargetInReplacement(nodes: readonly NodeView[], offset: number): {
+    index: number;
+    offset: number;
+};
+/** What a splice settled: its change widened by every fold, and where a tracked index landed. */
+export interface SettledSplice {
+    change: StructuralChange;
+    landing: number;
+}
+/**
+ * The seam question at every join the splice at `at` disturbed, its window's two edges and the
+ * joins inside it, since a move can invalidate a join that was already correct. Each fold
+ * cascades downward. `headProbe` names the one block whose bytes changed, letting each ask
+ * decline on its first line alone; dropped once anything folds, since its index has moved.
+ */
+export declare function absorbWindowSeams(parent: NodeParent, at: number, added: number, landing: number, change: StructuralChange, sharing?: SharingState, tracked?: TrackedPosition, headProbe?: number, onBeforeSplice?: () => void): SettledSplice;
+/** The materialized tail reported inside the sink's one contiguous window. */
+export declare function widenForTailMint(change: StructuralChange, before: number, after: number): StructuralChange;
+/**
+ * Remove the node at `blockIndex`, leaving the next sibling separated from its new predecessor
+ * and no more. Takes {@link BodyParentArg} because the settle can hand a freed line to the
+ * owner's wrap slots; the successor's trivia is the op's only in-place write.
+ */
+export declare function deleteNode(parent: BodyParentArg, blockIndex: number, sharing?: SharingState): StructuralChange;
+export {};