@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/tree-operations/paste/table-slice.js

@@ -3,37 +3,42 @@
  * preserves caret continuity for the break-and-splice paste path.
  */
 import { metadataOf } from '../../core/nodes';
-import { rebuildContainerRaw } from '../../schema/container-raw';
+import { rebuildTableRaw, tableLineEnding } from '../../schema/container-rebuilders';
+import { promoteFirstRowToHeader } from '../table-mutations';
 export function sliceTableAtRow(table, sliceRow, rowGoes) {
     const rows = table.children;
     const meta = metadataOf(table, 'table');
     const splitAt = rowGoes === 'first' ? sliceRow + 1 : sliceRow;
     const firstRows = rows.slice(0, splitAt);
     const secondRows = rows.slice(splitAt);
-    const firstHalf = buildHalf(firstRows, meta);
-    const secondHalf = buildHalf(secondRows, meta);
+    const ending = tableLineEnding(table);
+    const firstHalf = buildHalf(firstRows, meta, ending);
+    const secondHalf = buildHalf(secondRows, meta, ending);
     if (firstHalf)
-        rebuildContainerRaw(firstHalf);
+        rebuildTableRaw(firstHalf);
     if (secondHalf)
-        rebuildContainerRaw(secondHalf);
+        rebuildTableRaw(secondHalf);
     return { firstHalf, secondHalf };
 }
-function buildHalf(rows, sourceMeta) {
+function buildHalf(rows, sourceMeta, ending) {
     if (rows.length === 0)
         return null;
-    const cloned = rows.map((row, idx) => ({
+    const cloned = rows.map((row) => ({
         ...row,
-        metadata: { isHeader: idx === 0 },
+        metadata: { ...metadataOf(row, 'tableRow'), isHeader: false },
         children: row.children.map((cell) => ({ ...cell }))
     }));
-    return {
+    const half = {
         kind: 'table',
         leadingTrivia: '',
-        raw: '',
+        // The rebuild reads the line ending off the raw it replaces.
+        raw: ending,
         metadata: {
             columnCount: sourceMeta.columnCount,
             alignments: sourceMeta.alignments.slice()
         },
         children: cloned
     };
+    promoteFirstRowToHeader(half);
+    return half;
 }

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

@@ -1,22 +1,13 @@
-import type { UndoEntryMode } from '../action-contracts';
-import type { AnyBlockKind, CstNode, Document } from '../core/nodes';
-import type { PresentationMode } from '../presentation-mode';
-import type { InlineResolverRef } from '../schema/inline-construct-policy';
-import type { GrammarView } from '../schema/block-openers';
+import { type AnyBlockKind, type CstNode, type Document } from '../core/nodes';
+import type { LineEnding } from '../core/lines';
+import type { StoredAs } from '../schema/stored-as';
+import type { ChildSlot } from './list/task-paragraph';
 import type { PasteCommitCoordinator } from './paste/paste-deps';
+import type { PluginActivation } from '../schema/plugin-activation';
 export interface PasteRange {
     start: number;
     end: number;
 }
-/**
- * What the join-seam cleanup needs from the caller: the paste's delete half is a join, and in
- * live the runs it strands are bytes the reader never saw. Absent leaves the cut byte-literal,
- * which is every non-live mode's answer anyway.
- */
-export interface PasteSeam {
-    presentationMode: PresentationMode | undefined;
-    linkRef: InlineResolverRef | undefined;
-}
 export interface InlinePasteResult {
     /** New raw for the target node (including trailing line ending). */
     newRaw: string;
@@ -33,22 +24,18 @@ export interface ScopedStructuralPasteInput {
     /** Pasted blocks, blank-line-materialized. */
     blocks: CstNode[];
     controller: PasteCommitCoordinator;
-    undoEntry: UndoEntryMode;
-    /** The instance grammar the splice owes its bodyWrite escape reparse. Required-nullable, so
-     *  a new scoped surface cannot silently drop it; `undefined` = global. */
-    grammar: GrammarView | undefined;
 }
 export interface PasteSurface {
     kind: AnyBlockKind;
-    /**
-     * This surface holds text, never blocks (a table cell), so a blank block at the clipboard's
-     * edge is the copy's packaging: it neither picks the route nor lands in a structural splice.
-     */
+    /** The kind's editable element holds text, never blocks (a table cell), so a blank block at the
+     *  clipboard's edge is packaging: it neither picks the route nor lands in a splice. */
     blankEdgesArePackaging?: boolean;
-    /** Splice `text` into `node` at `offset` (optionally pre-deleting a range). Pure. */
-    onInlinePaste?(node: CstNode, offset: number, text: string, preDelete?: PasteRange, seam?: PasteSeam): InlinePasteResult;
-    /** Splice CST blocks at the target. Pure data transform. */
-    onStructuralPaste?(node: CstNode, offset: number, blocks: CstNode[], preDelete?: PasteRange, seam?: PasteSeam): StructuralPasteResult;
+    /** Pure. The pasted text replaces the pre-delete through `replaceRangeInLeaf`, as typing it
+     *  would; every line the hook writes takes `lineEnding`, the document's. */
+    onInlinePaste?(node: CstNode, offset: number, text: string, preDelete: PasteRange | undefined, store: StoredAs, lineEnding: LineEnding): InlinePasteResult;
+    /** Splice CST blocks at the target. Pure data transform. `slot` is where the target sits, so
+     *  the text the hook leaves there is read as a reload reads it. */
+    onStructuralPaste?(node: CstNode, offset: number, blocks: CstNode[], preDelete: PasteRange | undefined, store: StoredAs, lineEnding: LineEnding, slot: ChildSlot): StructuralPasteResult;
     /**
      * Structural paste whose splice scope is an ancestor (a tableCell splices at the
      * table's parent). The hook owns the whole mutation; dispatch does nothing afterward.
@@ -56,6 +43,8 @@ export interface PasteSurface {
     onScopedStructuralPaste?(input: ScopedStructuralPasteInput): Promise<void>;
 }
 export declare function registerPasteSurface(surface: PasteSurface): void;
-export declare function getPasteSurface(kind: AnyBlockKind): PasteSurface | undefined;
-export declare function __resetPasteSurfacesForTests(): void;
-export declare function __removePasteSurfaceForTests(kind: AnyBlockKind): void;
+/** The kind's surface in an editor with this activation; a plugin kind's surface is absent where
+ *  the editor left out the kind's plugin, so the paste takes the default hooks. */
+export declare function getPasteSurface(kind: AnyBlockKind, activation: PluginActivation): PasteSurface | undefined;
+/** Whether any plugin or built-in registered a surface for the kind, whatever the activation. */
+export declare function isPasteSurfaceRegistered(kind: AnyBlockKind): boolean;

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

@@ -1,15 +1,19 @@
-import { registerOnce } from '../schema/register-once';
+import { isBuiltinBlockKind } from '../core/nodes';
+import { createBlockKindRegistry } from '../schema/plugin-registry';
 // ── Registry ───────────────────────────────────────────────────────────────
-const surfaces = new Map();
+const surfaces = createBlockKindRegistry({
+    label: 'registerPasteSurface',
+    isBuiltin: isBuiltinBlockKind
+});
 export function registerPasteSurface(surface) {
-    registerOnce(surfaces.has(surface.kind), () => surfaces.set(surface.kind, surface), `registerPasteSurface: "${surface.kind}" is already registered. Paste surfaces are register-once.`);
+    surfaces.register(surface.kind, surface, `registerPasteSurface: "${surface.kind}" is already registered. Paste surfaces are register-once.`);
 }
-export function getPasteSurface(kind) {
-    return surfaces.get(kind);
+/** The kind's surface in an editor with this activation; a plugin kind's surface is absent where
+ *  the editor left out the kind's plugin, so the paste takes the default hooks. */
+export function getPasteSurface(kind, activation) {
+    return surfaces.get(kind, activation);
 }
-export function __resetPasteSurfacesForTests() {
-    surfaces.clear();
-}
-export function __removePasteSurfaceForTests(kind) {
-    surfaces.delete(kind);
+/** Whether any plugin or built-in registered a surface for the kind, whatever the activation. */
+export function isPasteSurfaceRegistered(kind) {
+    return surfaces.has(kind);
 }

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

@@ -1,12 +1,11 @@
 /**
- * Path-addressed child splices for the range-delete ceremony. Both route through
- * `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
- * spine themselves; `sharing` is what unshares the children the settle touches.
+ * Path-addressed child splices for the range delete, through `spliceChildrenSettled` so a
+ * container at any depth keeps its `childIds` and separators right. `sharing` is required, since
+ * the fix-up writes neighbours' bytes that an undo snapshot may share (G1.9). Callers copy the
+ * parent chain themselves; `sharing` copies the children the fix-up touches.
  */
 import type { CstNode, Document } from '../core/nodes';
+import type { GrammarView } from '../schema/block-openers';
 import type { SharingState } from './sharing';
-export declare function deleteAtPath(doc: Document, path: number[], sharing: SharingState): void;
-export declare function replaceAtPath(doc: Document, path: number[], replacement: CstNode[], sharing: SharingState): void;
+export declare function deleteAtPath(doc: Document, path: number[], sharing: SharingState, grammar: GrammarView): void;
+export declare function replaceAtPath(doc: Document, path: number[], replacement: CstNode[], sharing: SharingState, grammar: GrammarView): void;

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

@@ -1,6 +1,6 @@
 import { nodeAt } from './node-primitives';
 import { spliceChildrenSettled } from './settle';
-export function deleteAtPath(doc, path, sharing) {
+export function deleteAtPath(doc, path, sharing, grammar) {
     if (path.length === 0)
         return;
     const parent = nodeAt(doc, path.slice(0, -1));
@@ -8,14 +8,14 @@ export function deleteAtPath(doc, path, sharing) {
         return;
     const idx = path[path.length - 1];
     if (idx < parent.children.length) {
-        spliceChildrenSettled(parent, idx, 1, [], sharing);
+        spliceChildrenSettled(parent, idx, 1, [], grammar, sharing);
     }
 }
-export function replaceAtPath(doc, path, replacement, sharing) {
+export function replaceAtPath(doc, path, replacement, sharing, grammar) {
     if (path.length === 0)
         return;
     const parent = nodeAt(doc, path.slice(0, -1));
     if (!parent || !parent.children)
         return;
-    spliceChildrenSettled(parent, path[path.length - 1], 1, replacement, sharing);
+    spliceChildrenSettled(parent, path[path.length - 1], 1, replacement, grammar, sharing);
 }

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

@@ -1,9 +1,8 @@
 /**
- * Resolve the reorderable unit a path points into: the nearest ancestor slot whose parent
- * reorders its children among themselves. Membership is the parent's declared
- * `reorderChildren` capability, never a kind name, so a plugin container opts in as the
- * built-ins do. An opaque container is a hard boundary — reorder DECLINES there rather
- * than walking past to the document and teleporting the container to a top-level index.
+ * Resolve the reorderable unit a path points into: the nearest position whose parent declares
+ * `reorderChildren`, a capability rather than a kind name, so a plugin container opts in as the
+ * built-ins do. An opaque container is a hard boundary: reorder declines there rather than move
+ * the whole container to a top-level index.
  */
 import type { Document } from '../core/nodes';
 export interface ReorderUnit {

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

@@ -1,16 +1,15 @@
 /**
- * Resolve the reorderable unit a path points into: the nearest ancestor slot whose parent
- * reorders its children among themselves. Membership is the parent's declared
- * `reorderChildren` capability, never a kind name, so a plugin container opts in as the
- * built-ins do. An opaque container is a hard boundary — reorder DECLINES there rather
- * than walking past to the document and teleporting the container to a top-level index.
+ * Resolve the reorderable unit a path points into: the nearest position whose parent declares
+ * `reorderChildren`, a capability rather than a kind name, so a plugin container opts in as the
+ * built-ins do. An opaque container is a hard boundary: reorder declines there rather than move
+ * the whole container to a top-level index.
  */
 import { tryGetBlockKindDescriptor } from '../schema/block-kind-descriptor';
 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);
-        // The root is identified structurally, never by kind: a plugin may mint 'document'
+        // The root is identified structurally, never by kind: a plugin may register 'document'
         // as a block kind, and such a node is just another container.
         if (parentPath.length === 0) {
             return { parentPath, index: path[depth - 1], scope: 'document', renumberMarkers: false };

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

@@ -1,16 +1,14 @@
 import type { CstNode } from '../core/nodes';
 import type { SharingState } from './sharing';
+import type { BodyParent } from './node-primitives';
 import { type SettledSplice } from './settle';
 import type { StructuralChange } from './structural-change';
+import type { GrammarView } from '../schema/block-openers';
 export declare function reorderChildren(children: CstNode[], from: number, to: number): StructuralChange;
 /**
- * Reorder children while keeping block separators positional. A separator is stored as the next
- * child's `leadingTrivia` but read per slot, so it belongs to the position, not the node. Writing
- * it is a byte write, so spanned children are unshared first (`unshare.ts`) and `children` must
- * already be an owned array. The landing rides the result: a fold settling a seam the move
- * invalidated can sit above the moved block.
+ * Reorder a body's children, each separator staying with its position rather than its node. The
+ * children must be an owned array; the result's `landing` counts any merge the move set off.
  */
-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;
+export declare function reorderChildrenWithTrivia(body: BodyParent, from: number, to: number, sharing: SharingState, 
+/** The editor's grammar, in which the checks below reread each pair of moved blocks. */
+grammar: GrammarView): SettledSplice;

package/dist/tree-operations/reorder.js

@@ -1,10 +1,11 @@
-import { isBlankParagraph, parse } from '../core/parser';
-import { trailingLineEnding } from '../core/lines';
+import { isBlankParagraph, readBlocks } from '../core/parser';
+import { lineEndingAt, ownTrailingLineEnding } from '../core/lines';
 import { ensureUnsharedChild } from './unshare';
+import { endWindowLines } from './open-tail';
 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.
+// $state tree, so both entry points check the bounds before any copy or write.
 function isReorderOutOfBounds(from, to, len) {
     if (from < 0 || from >= len || to < 0 || to >= len) {
         devWarn('reorder', `reorder out of bounds: from=${from} to=${to} len=${len}`);
@@ -13,7 +14,7 @@ function isReorderOutOfBounds(from, to, len) {
     return false;
 }
 // A reorder rewrites no bytes and creates no node: it is one contiguous `replace`
-// whose idMap permutes the spanned window so each moved block keeps its id + ref.
+// whose idMap permutes the spanned window so each moved block keeps its id and ref.
 export function reorderChildren(children, from, to) {
     if (from === to)
         return { op: 'noop' };
@@ -33,16 +34,13 @@ export function reorderChildren(children, from, to) {
     return { op: 'replace', at: lo, count, newCount: count, idMap };
 }
 /**
- * Reorder children while keeping block separators positional. A separator is stored as the next
- * child's `leadingTrivia` but read per slot, so it belongs to the position, not the node. Writing
- * it is a byte write, so spanned children are unshared first (`unshare.ts`) and `children` must
- * already be an owned array. The landing rides the result: a fold settling a seam the move
- * invalidated can sit above the moved block.
+ * Reorder a body's children, each separator staying with its position rather than its node. The
+ * children must be an owned array; the result's `landing` counts any merge the move set off.
  */
-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) {
+export function reorderChildrenWithTrivia(body, from, to, sharing, 
+/** The editor's grammar, in which the checks below reread each pair of moved blocks. */
+grammar) {
+    const children = body.children;
     if (from === to)
         return { change: { op: 'noop' }, landing: to };
     if (isReorderOutOfBounds(from, to, children.length)) {
@@ -50,6 +48,8 @@ separators = false) {
     }
     const lo = Math.min(from, to);
     const hi = Math.max(from, to);
+    // Whether the moved block sat flush against both its neighbours, read before the rotation.
+    const flushAround = !children[from].leadingTrivia && !children[from + 1]?.leadingTrivia;
     const windowTrivia = [];
     for (let i = lo; i <= hi; i++) {
         windowTrivia.push(ensureUnsharedChild({ children }, i, sharing).leadingTrivia);
@@ -58,50 +58,49 @@ separators = false) {
     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);
-        }
+    // The joins below read the moved blocks side by side, so a moved open last line ends first; this
+    // call goes once the commit settles the move's joins, and the commit gives the ending back.
+    endWindowLines(body, change, sharing, grammar);
+    // Each join the move touches gets a blank line where the two blocks would read as one; the
+    // pair the moved block left rejoins only if it sat flush against both of them.
+    const vacated = from < to ? from : from + 1;
+    for (let at = lo; at <= hi + 1; at++) {
+        if (at !== vacated || !flushAround)
+            separateSeam(children, at, sharing, grammar);
     }
-    return absorbWindowSeams({ children }, lo, hi - lo + 1, to, change, sharing);
+    // A blank block moved by position can hold a line its follower holds too; the run needs
+    // 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, grammar, 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.
+ * Give the follower at `at` a separator only where the reload would not read the two blocks back
+ * as themselves; a block that swallows across a blank line is left to the neighbour merge.
  */
-function separateSeam(children, at, sharing) {
+function separateSeam(children, at, sharing, grammar) {
     if (at <= 0 || at >= children.length)
         return;
     const prev = children[at - 1];
     const next = children[at];
-    const apart = withLeadingLine(next.leadingTrivia, trailingLineEnding(next.raw));
+    // The block above is not the last, so its line ending is the document's.
+    const apart = withLeadingLine(next.leadingTrivia, ownTrailingLineEnding(prev.raw));
     if (apart === next.leadingTrivia)
         return;
-    if (readsAsBoth(prev, next.leadingTrivia, next) || !readsAsBoth(prev, apart, next))
+    const readsAsBoth = (trivia) => readsAsPair(prev, trivia, next, grammar);
+    if (readsAsBoth(next.leadingTrivia) || !readsAsBoth(apart))
         return;
     ensureUnsharedChild({ children }, at, sharing).leadingTrivia = apart;
 }
 function withLeadingLine(trivia, eol) {
-    return trivia.startsWith('\n') || trivia.startsWith('\r\n') ? trivia : eol + trivia;
+    return lineEndingAt(trivia, 0) !== '' ? 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;
+function readsAsPair(prev, trivia, next, grammar) {
+    const blocks = readBlocks(prev.raw + trivia + next.raw, { grammar, scope: 'fragment' }).children;
     return (blocks.length === 2 &&
         blocks[0].kind === prev.kind &&
         blocks[0].raw === prev.raw &&

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

@@ -1,105 +1,94 @@
 /**
- * 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.
+ * Recomputes the blank-line separators an edit left stale, merges neighbours that would re-read
+ * as one block on reload, and deletes a block on top of both (`docs/design/syntax-tree.md` § Blank
+ * lines). Every in-place write goes through `sharing`, so no undo snapshot sees it (G1.9), and
+ * `lint/separator-write-doors.test.ts` must list every function here that writes a separator.
  */
 import type { CstNode, Document } from '../core/nodes';
 import type { NodeView } from '../core/node-views';
+import type { GrammarView } from '../schema/block-openers';
 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.
+ * Drop the separator at `index` where 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.
+ * A blank block is itself a blank line, so it and its follower share one separator (G2.13). The
+ * follower's is kept, so filling the blank block later 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.
+ * between it and a non-blank predecessor. Call when the block is filled.
  */
 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).
+ * The separator the block below a consumed blank line takes back, skipped for a blank block whose
+ * follower already holds one, since the two share it (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.
+ * A block turned blank joins a run that, with its follower, must carry exactly one separating line;
+ * a standing line is kept, and a new one goes at the run's head, the only place one may sit.
  */
 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.
+ * A tail block that stops being blank gives back the `innerSuffix` line {@link
+ * settleSeparatorOnBlank} lent it, or the container 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.
+ * The commit's entry point: recompute the separators around `change`'s window against `before`,
+ * the children before the mutation. A node that survives inside the window counts as kept.
  */
-export declare function settleSeparator(parent: SeparatorParent, before: readonly CstNode[], change: StructuralChange, sharing?: SharingState, tracked?: TrackedPosition): StructuralChange;
+export declare function settleSeparator(parent: SeparatorParent, before: readonly CstNode[], change: StructuralChange, grammar: GrammarView, 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.
+ * {@link settleSeparator} for a splice outside a commit scope, into a container found by walking
+ * the live tree; `spliceChildren` keeps its `childIds` in step.
  */
+export declare function spliceChildrenSettled(parent: CstNode | Document, at: number, removeCount: number, replacement: CstNode[], grammar: GrammarView, sharing?: SharingState): void;
+/** What a merge of neighbours absorbed; `span + eaten` is the block count before the merge, the
+ *  figure 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. */
+/** A byte position the merges keep updated, written in place since each merge re-divides the
+ *  bytes into blocks. */
 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.
+ * Merge neighbours while their joined bytes reload as fewer blocks or move content into the head;
+ * blank lines don't end a container, so the window starts at the nearest non-blank block above.
  */
+export declare function absorbSeamReading(parent: NodeParent, seamLeft: number, floor: number, grammar: GrammarView, sharing?: SharingState, tracked?: TrackedPosition, headProbe?: number, onBeforeSplice?: () => void): SeamAbsorption;
+/** The block a caret offset into the committed bytes falls in, and its offset there. An offset in
+ *  the blank lines between blocks lands at the next block's start. */
 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. */
+/** What settling a splice produced: its change widened by every merge, and where a tracked
+ *  index ended up. */
 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. */
+/** Merge across every join the splice at `at` disturbed, the joins inside the window included,
+ *  since a move can break a join that was correct. `headProbe` names the one changed block. */
+export declare function absorbWindowSeams(parent: NodeParent, at: number, added: number, landing: number, change: StructuralChange, grammar: GrammarView, sharing?: SharingState, tracked?: TrackedPosition, headProbe?: number, onBeforeSplice?: () => void): SettledSplice;
+/** The tail line that became a block, reported inside the caller'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;
+/** The kind whose body these children are: the named owner's, or the parent node's own. */
+export declare function ownerKindNameOf(parent: SeparatorParent): string | undefined;
+/** Remove the node at `blockIndex`, leaving its successor separated once and no more. Takes
+ *  {@link BodyParentArg} since the fix-up can move a freed line into the owner's `innerPrefix`. */
+export declare function deleteNode(parent: BodyParentArg, blockIndex: number, grammar: GrammarView, sharing?: SharingState, tracked?: TrackedPosition): StructuralChange;
 export {};