@voithos-labs/aragonite 0.10.2 → 0.10.4

package/dist/tree-operations/chain-rebuild.js

@@ -0,0 +1,142 @@
+/**
+ * The ancestry rebuild: raws re-derived along an owned spine chain innermost-first, each
+ * container's kind re-derived and the seam at its own slot asked on the way out (editor.md § 9).
+ */
+import { dropChildSpans } from '../schema/child-spans';
+import { trimTrailingLineEnding } from '../core/lines';
+import { perfEnabled, recordRebuildDepth } from '../perf/instruments';
+import { rebuildOwnedContainer, walkUnsharing } from './unshare';
+import { absorbWindowSeams } from './settle';
+import { lineOpensAs, reclassifyContainer } from './content-write';
+import { settleSublistSeparator } from './list/sublist-separator';
+/**
+ * Longest prefix of `chain` still attached under `root`, identity-checked level by level. A
+ * commit mutation can splice a node out mid-ceremony, and rebuilding the detached node's raw
+ * against its emptied children writes `raw: ''`; ancestors above the detachment still rebuild.
+ */
+export function attachedChainPrefix(root, chain) {
+    let parentChildren = root.children;
+    for (let i = 0; i < chain.length; i++) {
+        if (!parentChildren.includes(chain[i]))
+            return chain.slice(0, i);
+        parentChildren = chain[i].children ?? [];
+    }
+    return chain;
+}
+/**
+ * Rebuild raws along an owned spine chain innermost-first, re-deriving each container's kind and
+ * settling the seams at its own slot; chain- rather than path-based so it survives index shifts.
+ * Both passes gate on a boundary line of the rebuilt raw moving. `folds` is required-nullable: a
+ * fold splices the PARENT's array, so only a caller that reconciles that scope's ids/refs passes
+ * a sink.
+ */
+export function rebuildUnsharedChain(root, chain, sharing, folds, grammar, hint) {
+    const reclassified = [];
+    // The bytes chain[i + 1] held before this pass. It rides up only from a door that named the
+    // leaf's own: a caller passing no hint re-derives at every level (editor.md § 9).
+    let childPreviousRaw;
+    for (let i = chain.length - 1; i >= 0; i--) {
+        const node = chain[i];
+        const rawBefore = node.raw;
+        const child = chain[i + 1];
+        rebuildOwnedContainer(node, sharing, child && childPreviousRaw !== undefined
+            ? childRawChange(node, child, childPreviousRaw, hint?.path[i + 1])
+            : undefined);
+        if (hint)
+            childPreviousRaw = i === chain.length - 1 ? hint.leafPreviousRaw : rawBefore;
+        const openerMoved = firstLine(rawBefore) !== firstLine(node.raw);
+        const closerMoved = lastLine(rawBefore) !== lastLine(node.raw);
+        if (!openerMoved && !closerMoved)
+            continue;
+        const owner = i === 0 ? null : chain[i - 1];
+        const siblings = (owner ?? root).children;
+        const index = siblings ? childIndexOf(siblings, node, hint?.path[i]) : -1;
+        if (!siblings || index < 0)
+            continue;
+        if (openerMoved && lineOpensAs(firstLine(node.raw), grammar) !== node.kind) {
+            const replacement = reclassifyContainer({ children: siblings }, index, grammar);
+            if (replacement) {
+                sharing.stamp(replacement);
+                reclassified.push({ siblings, index, previous: node, replacement });
+            }
+        }
+        // Ahead of the seam ask, which then reads the settled bytes: a list rebuilt down to an
+        // empty marker owes the paragraph above it a separating line.
+        if (openerMoved)
+            settleSublistSeparator(siblings, index);
+        // After the re-derive: the seam reads whatever occupies the slot now.
+        if (folds) {
+            const before = folds.length;
+            settleSlotSeams({ siblings, owner, depth: i, index, openerMoved, closerMoved }, sharing, folds);
+            // A fold re-tiled the owner's children, so its spans describe a shape that is gone.
+            if (folds.length > before && owner)
+                dropChildSpans(owner);
+        }
+    }
+    if (perfEnabled())
+        recordRebuildDepth(chain.length);
+    return reclassified;
+}
+/**
+ * The changed-child hint for `node`, or undefined when `child` cannot be placed in it. The path
+ * index is a guess; an identity match is what makes it an answer.
+ */
+function childRawChange(node, child, previousRaw, guess) {
+    const siblings = node.children;
+    if (!siblings)
+        return undefined;
+    const index = childIndexOf(siblings, child, guess);
+    return index < 0 ? undefined : { index, previousRaw };
+}
+/** `indexOf` with a guess first: the scan is O(children) through the `$state` proxy. */
+function childIndexOf(siblings, child, guess) {
+    if (guess !== undefined && siblings[guess] === child)
+        return guess;
+    return siblings.indexOf(child);
+}
+/**
+ * Ask the joins at a rebuilt container's slot, since its new bytes can stop interrupting a
+ * neighbour. `absorbWindowSeams` walks `at - 1 … at + added - 1`, so the two arguments below
+ * name exactly the sides whose line moved.
+ */
+function settleSlotSeams(slot, sharing, folds) {
+    const { siblings, index, openerMoved, closerMoved } = slot;
+    // The rollback snapshot is captured only once a fold is certain: an eager copy here cost
+    // O(children) reactive reads on every keystroke inside a large container.
+    let before = null;
+    const landing = { index, offset: 0 };
+    const settled = absorbWindowSeams({ children: siblings }, openerMoved ? index : index + 1, openerMoved && closerMoved ? 1 : 0, index, { op: 'noop' }, sharing, landing, index, () => {
+        before ??= siblings.slice();
+    });
+    if (settled.change.op === 'noop')
+        return;
+    folds.push({
+        depth: slot.depth,
+        siblings,
+        owner: slot.owner,
+        change: settled.change,
+        // A non-noop change means a splice ran, so the capture ran first.
+        before: before,
+        landing
+    });
+}
+/** The container's opener line. */
+function firstLine(raw) {
+    const nl = raw.indexOf('\n');
+    return nl < 0 ? raw : raw.slice(0, nl);
+}
+/** The container's closing line: its last line carrying bytes, without the ending. */
+function lastLine(raw) {
+    const body = trimTrailingLineEnding(raw);
+    const nl = body.lastIndexOf('\n');
+    return nl < 0 ? body : body.slice(nl + 1);
+}
+/**
+ * Unshare the spine to `path` and rebuild it innermost-first, tolerating paths that ran out of
+ * range mid-walk (post-delete rebuild passes). Prefer `rebuildUnsharedChain` when indices may
+ * have shifted since the unshare.
+ */
+export function rebuildUnsharedAncestry(root, path, sharing, folds, grammar) {
+    const chain = walkUnsharing(root, path, sharing, false);
+    return rebuildUnsharedChain(root, chain, sharing, folds, grammar);
+}

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

@@ -1,6 +1,6 @@
 /**
  * Container children mutations that keep `childIds` in lockstep, for out-of-commit-scope
- * writes (discovered descendants/ancestors — see the `node-ops.ts` header). Inside a
+ * writes (discovered descendants/ancestors — see the `node-primitives.ts` header). Inside a
  * commit scope the StructuralChange descriptor owns id/ref sync; here a hand-rolled
  * splice would let the parallel id array drift and break Svelte's keyed-each rendering.
  * The same shape change invalidates `childSpans`, so both parallel arrays settle here.

package/dist/tree-operations/children.js

@@ -1,6 +1,6 @@
 /**
  * Container children mutations that keep `childIds` in lockstep, for out-of-commit-scope
- * writes (discovered descendants/ancestors — see the `node-ops.ts` header). Inside a
+ * writes (discovered descendants/ancestors — see the `node-primitives.ts` header). Inside a
  * commit scope the StructuralChange descriptor owns id/ref sync; here a hand-rolled
  * splice would let the parallel id array drift and break Svelte's keyed-each rendering.
  * The same shape change invalidates `childSpans`, so both parallel arrays settle here.

package/dist/tree-operations/cleanup.js

@@ -1,4 +1,4 @@
-import { spliceChildrenSettled } from './node-ops';
+import { spliceChildrenSettled } from './settle';
 import { ensureUnsharedPath } from './unshare';
 /**
  * Walk up from `deletedPath`'s parent, removing containers emptied by the cleanup. Stops

package/dist/tree-operations/content-write.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The content write: every byte that enters a node crosses `updateNodeContent`, the sole
+ * re-parse transfer funnel (editor.md § 6, § 8), and the container twin that re-derives a
+ * container's kind from its rebuilt raw.
+ */
+import type { AnyBlockKind, CstNode } 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 } from './node-primitives';
+/** What a content write settled: its change widened by every fold, and the offset the written
+ *  text starts at inside that change's window (nonzero once a fold above absorbed it). */
+export interface SettledContent {
+    change: StructuralChange;
+    textStart: number;
+}
+/**
+ * Update raw and re-parse. A kind change mints the reparsed block into the slot rather than
+ * reassigning `kind` in place, and multi-block text mints every parsed block; only a same-kind
+ * single-block edit writes in place, so routine typing keeps the node's object identity.
+ */
+export declare function updateNodeContent(parent: BodyParentArg, blockIndex: number, text: string, grammar?: GrammarView, sharing?: SharingState): SettledContent;
+/**
+ * Refresh a node in place from its own reparse, keeping its object identity. The id resync is
+ * unconditional: the reparse can change the child count while the caller reports `noop`.
+ */
+export declare function adoptReparsedFields(target: CstNode, parsed: CstNode | undefined): void;
+/**
+ * What the grammar opens `line` as, read in isolation: asked of the opener registry and never
+ * a kind list, so a kind registered later is covered the day it registers.
+ */
+export declare function lineOpensAs(line: string, grammar?: GrammarView): AnyBlockKind;
+/** Whether the ambient grammar still leaves `NEXT_PROSE_LINE` an ordinary paragraph. */
+export declare function probeLineOpensAsProse(grammar?: GrammarView): boolean;
+/**
+ * Re-derive the container at `index` from its own (already rebuilt) raw, replacing it in the
+ * slot when that raw now opens as a different kind (editor.md § 8). Eligibility is the opener
+ * registry: registering an opener is exactly the claim that `parse(raw)` reproduces the kind.
+ */
+export declare function reclassifyContainer(parent: NodeParent, index: number, grammar?: GrammarView): CstNode | null;
+/**
+ * Where a caret at `offset` in the written text lands once {@link updateNodeContent}'s folds
+ * settled: an absorb ABOVE leaves the predecessor holding the bytes, so the slot the gesture
+ * named is gone and the offset carries what that predecessor put in front of it.
+ */
+export declare function settledCaretTarget(settled: SettledContent, at: number, offset: number, children: readonly NodeView[]): {
+    index: number;
+    offset: number;
+};

package/dist/tree-operations/content-write.js

@@ -0,0 +1,263 @@
+/**
+ * The content write: every byte that enters a node crosses `updateNodeContent`, the sole
+ * re-parse transfer funnel (editor.md § 6, § 8), and the container twin that re-derives a
+ * container's kind from its rebuilt raw.
+ */
+import { isBlankParagraph, parse } from '../core/parser';
+import { escalatedFenceLength, matchFenceOpen } from '../core/parsers/fence-syntax';
+import { isBlockOpenerRegistered } from '../schema/block-openers';
+import { trailingLineEnding } from '../core/lines';
+import { assignChildIdsDeep } from '../block-id';
+import { perfEnabled, recordContainerKindReparse } from '../perf/instruments';
+import { getBlockKindDescriptor, tryGetBlockKindDescriptor } from '../schema/block-kind-descriptor';
+import { resyncChildIds } from './children';
+import { spliceMany } from './splice-many';
+import { replacePreservingFirst } from './structural-change';
+import { NEXT_PROSE_LINE, ensureEditableContainers, forBody, writeOwnRaw } from './node-primitives';
+import { absorbWindowSeams, focusTargetInReplacement, releaseWrapPeel, restoreSeparatorAfterBlank, restoreSeparatorOnFill, settleSeparatorOnBlank, widenForTailMint } from './settle';
+/**
+ * Update raw and re-parse. A kind change mints the reparsed block into the slot rather than
+ * reassigning `kind` in place, and multi-block text mints every parsed block; only a same-kind
+ * single-block edit writes in place, so routine typing keeps the node's object identity.
+ */
+export function updateNodeContent(parent, blockIndex, text, grammar, sharing) {
+    const wasBlank = isBlankParagraph(parent.children[blockIndex]);
+    const change = writeParsedContent(parent, blockIndex, text, grammar);
+    const lastWritten = lastMintedIndex(change, blockIndex);
+    // One blank line served BOTH sides: it separated this block from the one above and stood in
+    // as the separator of the block beneath it. Ending it owes each their own.
+    if (wasBlank && !isBlankParagraph(parent.children[blockIndex])) {
+        restoreSeparatorOnFill(parent, blockIndex, sharing);
+        restoreSeparatorAfterBlank(parent, followerIndexAfter(change, blockIndex), sharing);
+        releaseWrapPeel(parent, lastWritten);
+        return settleWriteSeams(parent, blockIndex, lastWritten, change, sharing);
+    }
+    // The reverse transition: the block IS the separating line now, so the run it joins gives
+    // back the second one. The last block minted is the one that meets the follower.
+    if (!wasBlank && isBlankParagraph(parent.children[lastWritten])) {
+        const settled = parent.children.length;
+        settleSeparatorOnBlank(parent, lastWritten, sharing);
+        const widened = widenForTailMint(change, settled, parent.children.length);
+        return settleWriteSeams(parent, blockIndex, lastWritten, widened, sharing);
+    }
+    // Same-kind typing INSIDE content must never pay a neighbour reparse.
+    if (change.op === 'noop')
+        return { change, textStart: 0 };
+    return settleWriteSeams(parent, blockIndex, lastWritten, change, sharing);
+}
+/**
+ * Ask every join the write disturbed and report where the written text ended up: an absorb
+ * ABOVE leaves the predecessor standing, so its bytes now sit in front of the text.
+ */
+function settleWriteSeams(parent, blockIndex, lastWritten, change, sharing) {
+    const tracked = { index: blockIndex, offset: 0 };
+    const settled = absorbWindowSeams(parent, blockIndex, lastWritten - blockIndex + 1, blockIndex, change, sharing, tracked);
+    return {
+        change: settled.change,
+        textStart: textOffsetInWindow(parent.children, settled.change, tracked)
+    };
+}
+/**
+ * The tracked position as an offset in the settled window's committed text, the space every
+ * caret door measures in, where the head block's own leading trivia is outside the window.
+ */
+function textOffsetInWindow(children, change, tracked) {
+    const at = change.op === 'noop' ? tracked.index : change.at;
+    let pos = 0;
+    for (let i = at; i < tracked.index; i++) {
+        pos += (i === at ? 0 : children[i].leadingTrivia.length) + children[i].raw.length;
+    }
+    const ownTrivia = tracked.index > at ? children[tracked.index].leadingTrivia.length : 0;
+    return pos + ownTrivia + tracked.offset;
+}
+/** Where the filled block's follower ended up: a multi-block reparse pushes it down. */
+function followerIndexAfter(change, blockIndex) {
+    return change.op === 'replace' ? change.at + change.newCount : blockIndex + 1;
+}
+/** The last block the write left in the slot: a multi-block reparse mints past the first. */
+function lastMintedIndex(change, blockIndex) {
+    return change.op === 'replace' ? change.at + change.newCount - 1 : blockIndex;
+}
+/**
+ * The written bytes parsed, with the construct they leave OPEN closed off first: an unterminated
+ * construct reads every block below it as its body at the next parse, and the seam settle would
+ * converge the live tree to exactly that reading.
+ */
+function closeWrittenConstruct(parent, blockIndex, text, oldKind, grammar) {
+    // Fragment scope: this is one block's bytes, whatever its position, so a position-scoped
+    // kind must not mint here.
+    const parsed = parse(text, { grammar, scope: 'fragment' });
+    if (blockIndex + 1 >= parent.children.length)
+        return { text, parsed };
+    if (parsed.children.length === 1 && parsed.children[0].kind === oldKind)
+        return { text, parsed };
+    const terminator = openConstructTerminator(text, parsed.children, grammar);
+    if (!terminator)
+        return { text, parsed };
+    const closed = text + terminator;
+    return { text: closed, parsed: parse(closed, { grammar, scope: 'fragment' }) };
+}
+/**
+ * The terminator written bytes owe when their last construct absorbs to EOF, asked of the grammar
+ * rather than a kind list. Null when the bytes terminate themselves, or when no fence opener
+ * explains the absorb (the one family whose closer its opener determines).
+ */
+function openConstructTerminator(text, blocks, grammar) {
+    // The terminator is a line of its own, so bytes whose last line is still open have none to
+    // append to (G4.20's unterminated tail slice, which absorbs nothing while it stands alone).
+    if (!text.endsWith('\n') || blocks.length === 0)
+        return null;
+    const ending = trailingLineEnding(text);
+    const probe = parse(text + ending + NEXT_PROSE_LINE + ending, { grammar, scope: 'fragment' });
+    if (probe.children.length !== blocks.length)
+        return null;
+    const raw = blocks[blocks.length - 1].raw;
+    const nl = raw.indexOf('\n');
+    const opener = matchFenceOpen(nl < 0 ? raw : raw.slice(0, nl));
+    if (!opener)
+        return null;
+    const body = nl < 0 ? '' : raw.slice(nl + 1);
+    const run = escalatedFenceLength(body, opener.marker, opener.length);
+    return opener.indent + opener.marker.repeat(run) + ending;
+}
+function writeParsedContent(parent, blockIndex, text, grammar) {
+    const node = parent.children[blockIndex];
+    const oldKind = node.kind;
+    const oldDescriptor = getBlockKindDescriptor(oldKind);
+    // Ahead of every reparse below, so a write lands on the kind its committed bytes
+    // describe, not the kind the pre-escape text would parse to (`bodyWrite`).
+    const bodyText = forBody(parent, text);
+    // A context-dependent kind has no standalone recognizer, so reparsing would downgrade it:
+    // keep the kind and write raw through its own legality pass.
+    if (oldDescriptor.contextDependentKind) {
+        writeOwnRaw(node, bodyText, grammar);
+        return { op: 'noop' };
+    }
+    const { text: newText, parsed: reparsed } = closeWrittenConstruct(parent, blockIndex, bodyText, oldKind, grammar);
+    const parsed = reparsed.children;
+    const first = parsed[0];
+    // A marker-consuming container (a GitHub alert) needs its raw rebuilt from the backfilled
+    // body, or G1.1 stale-raw fires.
+    const firstBackfilled = !!first && isEmptyEditableContainer(first);
+    if (first)
+        ensureEditableContainers(first);
+    // Text-leading blanks fold into the first block's raw (the single-block shape); the
+    // rest keep their own trivia.
+    if (parsed.length > 1) {
+        const rest = parsed.slice(1);
+        for (const sibling of rest)
+            ensureEditableContainers(sibling);
+        first.raw = first.leadingTrivia + first.raw;
+        first.leadingTrivia = node.leadingTrivia;
+        if (firstBackfilled)
+            reconcileBackfilledRaw(first);
+        // The peeled line has no follower inside the splice, so it stays in raw.
+        rest[rest.length - 1].raw += reparsed.suffix;
+        spliceMany(parent.children, blockIndex, 1, parsed);
+        return replacePreservingFirst(blockIndex, 1, parsed.length);
+    }
+    const newKind = first?.kind ?? 'paragraph';
+    // In-place refresh keeps the node's object identity: component, IME state, and inline
+    // cache are all keyed on it.
+    if (newKind === oldKind) {
+        node.raw = newText;
+        adoptReparsedFields(node, first);
+        if (firstBackfilled)
+            reconcileBackfilledRaw(node);
+        return { op: 'noop' };
+    }
+    const replacement = first ?? { kind: 'paragraph', leadingTrivia: '', raw: newText };
+    replacement.raw = newText;
+    replacement.leadingTrivia = node.leadingTrivia;
+    if (firstBackfilled)
+        reconcileBackfilledRaw(replacement);
+    parent.children.splice(blockIndex, 1, replacement);
+    return replacePreservingFirst(blockIndex, 1, 1);
+}
+/**
+ * Refresh a node in place from its own reparse, keeping its object identity. The id resync is
+ * unconditional: the reparse can change the child count while the caller reports `noop`.
+ */
+export function adoptReparsedFields(target, parsed) {
+    target.metadata = parsed?.metadata;
+    target.children = parsed?.children;
+    resyncChildIds(target);
+    assignChildIdsDeep(target);
+    target.innerPrefix = parsed?.innerPrefix;
+    target.innerSuffix = parsed?.innerSuffix;
+}
+/** A container `ensureEditableContainers` will backfill; read BEFORE the backfill runs. */
+function isEmptyEditableContainer(node) {
+    const d = getBlockKindDescriptor(node.kind);
+    return d.isContainer && d.blockFocus !== 'whole-block' && (node.children?.length ?? 0) === 0;
+}
+/**
+ * Sync a just-backfilled container's `raw` to its synthesized body. Needed only for a
+ * marker-consuming container whose typed raw lacks a blank body line (`> [!TYPE]`).
+ */
+function reconcileBackfilledRaw(node) {
+    getBlockKindDescriptor(node.kind).rebuildRaw?.(node);
+}
+// ── Container kind re-derivation ──
+/**
+ * What the grammar opens `line` as, read in isolation: asked of the opener registry and never
+ * a kind list, so a kind registered later is covered the day it registers.
+ */
+export function lineOpensAs(line, grammar) {
+    return parse(`${line}\n`, { grammar, scope: 'fragment' }).children[0]?.kind ?? 'paragraph';
+}
+/** Whether the ambient grammar still leaves `NEXT_PROSE_LINE` an ordinary paragraph. */
+export function probeLineOpensAsProse(grammar) {
+    return lineOpensAs(NEXT_PROSE_LINE, grammar) === 'paragraph';
+}
+/**
+ * Re-derive the container at `index` from its own (already rebuilt) raw, replacing it in the
+ * slot when that raw now opens as a different kind (editor.md § 8). Eligibility is the opener
+ * registry: registering an opener is exactly the claim that `parse(raw)` reproduces the kind.
+ */
+export function reclassifyContainer(parent, index, grammar) {
+    const node = parent.children[index];
+    if (!node)
+        return null;
+    const descriptor = tryGetBlockKindDescriptor(node.kind);
+    if (!descriptor?.isContainer || !isBlockOpenerRegistered(node.kind))
+        return null;
+    if (perfEnabled())
+        recordContainerKindReparse();
+    const parsed = parse(node.raw, { grammar, scope: 'fragment' }).children;
+    // A container's raw is one block by construction; a multi-block reparse means bytes
+    // this seam has no slot for, left to the gesture that owns the mutation.
+    if (parsed.length !== 1 || parsed[0].kind === node.kind)
+        return null;
+    const replacement = parsed[0];
+    const backfilled = isEmptyEditableContainer(replacement);
+    ensureEditableContainers(replacement);
+    // The slot's trivia is authoritative, so restore the bytes before overwriting it or
+    // anything the parse split off the front vanishes with it.
+    replacement.raw = node.raw;
+    replacement.leadingTrivia = node.leadingTrivia;
+    if (backfilled)
+        reconcileBackfilledRaw(replacement);
+    // A freshly-parsed node carries no childIds and this swap publishes under the slot's
+    // reused component instance, so undefined keys would reach the nested keyed `{#each}`.
+    assignChildIdsDeep(replacement);
+    parent.children[index] = replacement;
+    // Write-then-re-read (tree-operations/unshare.ts header).
+    return parent.children[index];
+}
+/**
+ * Where a caret at `offset` in the written text lands once {@link updateNodeContent}'s folds
+ * settled: an absorb ABOVE leaves the predecessor holding the bytes, so the slot the gesture
+ * named is gone and the offset carries what that predecessor put in front of it.
+ */
+export function settledCaretTarget(settled, at, offset, children) {
+    const { change, textStart } = settled;
+    if (change.op !== 'replace')
+        return { index: at, offset };
+    const shifted = offset + textStart;
+    if (change.newCount <= 1)
+        return { index: change.at, offset: shifted };
+    const blocks = children.slice(change.at, change.at + change.newCount);
+    const target = focusTargetInReplacement(blocks, shifted);
+    return { index: change.at + target.index, offset: target.offset };
+}

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

@@ -1,5 +1,9 @@
-export type { NodeParent, MergeIntoPrevResult, MergeResult, SplitResult } from './node-ops';
-export { splitNode, assertSplitLanding, assertSingleNodeSink, mergeWithNext, mergeIntoPrevDeepLeaf, deleteNode, updateNodeContent, reclassifyContainer, focusTargetInReplacement, ensureEditableContainers, normalizeReplacementTrivia, emptyParagraph, paragraphNode, restoreSeparatorOnFill, dropDoubledSeparator, nodeAt } from './node-ops';
+export type { NodeParent } from './node-primitives';
+export { nodeAt, emptyParagraph, paragraphNode, ensureEditableContainers, normalizeReplacementTrivia } from './node-primitives';
+export { deleteNode, focusTargetInReplacement, restoreSeparatorOnFill, dropDoubledSeparator } from './settle';
+export { updateNodeContent, reclassifyContainer } from './content-write';
+export type { MergeIntoPrevResult, MergeResult, SplitResult } from './node-ops';
+export { splitNode, assertSplitLanding, assertSingleNodeSink, mergeWithNext, mergeIntoPrevDeepLeaf } from './node-ops';
 export { unwrapFirstItemFromList, mergeListItemIntoPrevious } from './list/unwrap-merge';
 export { renumberOrderedList, normalizeItemMarkerToList } from './list/ordered-markers';
 export { isItemUserEmpty } from './list/empty-check';
@@ -11,6 +15,7 @@ export { insertEmptyRow, insertEmptyColumn, deleteRow, deleteColumn, cycleAlignm
 export { copyRectangleAsSubTable } from './sub-table-copy';
 export type { CellPos } from './sub-table-copy';
 export { cascadeCleanupEmptyAncestors } from './cleanup';
-export { ensureUnsharedPath, ensureUnsharedChild, ensureUnsharedNode, ensureUnsharedChildren, ensureUnsharedSubtree, rebuildOwnedContainer, rebuildUnsharedChain, rebuildUnsharedAncestry } from './unshare';
+export { ensureUnsharedPath, ensureUnsharedChild, ensureUnsharedNode, ensureUnsharedChildren, ensureUnsharedSubtree, rebuildOwnedContainer } from './unshare';
+export { rebuildUnsharedChain, rebuildUnsharedAncestry } from './chain-rebuild';
 export { buildPastedReplacement } from './paste/paste-replacement';
 export { cloneDocument, cloneNode } from './clone';

package/dist/tree-operations/index.js

@@ -1,4 +1,7 @@
-export { splitNode, assertSplitLanding, assertSingleNodeSink, mergeWithNext, mergeIntoPrevDeepLeaf, deleteNode, updateNodeContent, reclassifyContainer, focusTargetInReplacement, ensureEditableContainers, normalizeReplacementTrivia, emptyParagraph, paragraphNode, restoreSeparatorOnFill, dropDoubledSeparator, nodeAt } from './node-ops';
+export { nodeAt, emptyParagraph, paragraphNode, ensureEditableContainers, normalizeReplacementTrivia } from './node-primitives';
+export { deleteNode, focusTargetInReplacement, restoreSeparatorOnFill, dropDoubledSeparator } from './settle';
+export { updateNodeContent, reclassifyContainer } from './content-write';
+export { splitNode, assertSplitLanding, assertSingleNodeSink, mergeWithNext, mergeIntoPrevDeepLeaf } from './node-ops';
 export { unwrapFirstItemFromList, mergeListItemIntoPrevious } from './list/unwrap-merge';
 export { renumberOrderedList, normalizeItemMarkerToList } from './list/ordered-markers';
 export { isItemUserEmpty } from './list/empty-check';
@@ -9,6 +12,7 @@ export { liftFirstChildKeepingContainer } from './container-lift';
 export { insertEmptyRow, insertEmptyColumn, deleteRow, deleteColumn, cycleAlignment } from './table-mutations';
 export { copyRectangleAsSubTable } from './sub-table-copy';
 export { cascadeCleanupEmptyAncestors } from './cleanup';
-export { ensureUnsharedPath, ensureUnsharedChild, ensureUnsharedNode, ensureUnsharedChildren, ensureUnsharedSubtree, rebuildOwnedContainer, rebuildUnsharedChain, rebuildUnsharedAncestry } from './unshare';
+export { ensureUnsharedPath, ensureUnsharedChild, ensureUnsharedNode, ensureUnsharedChildren, ensureUnsharedSubtree, rebuildOwnedContainer } from './unshare';
+export { rebuildUnsharedChain, rebuildUnsharedAncestry } from './chain-rebuild';
 export { buildPastedReplacement } from './paste/paste-replacement';
 export { cloneDocument, cloneNode } from './clone';

package/dist/tree-operations/list/exit-replacement.js

@@ -1,7 +1,7 @@
 import { metadataOf } from '../../core/nodes';
 import { trailingLineEnding } from '../../core/lines';
 import { cloneNode } from '../clone';
-import { emptyParagraph } from '../node-ops';
+import { emptyParagraph } from '../node-primitives';
 import { assembleListHalf } from './list-builders';
 import { partitionItemChildren } from './item-partition';
 import { orderedBaseOf } from './ordered-markers';

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

@@ -110,20 +110,20 @@ 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-ops.ts header
+                    // discovered-descendant mutation, see node-primitives.ts header
                     pushChild(depthOneList, item);
                 }
                 rebuildListRaw(depthOneList);
                 continue;
             }
-            // discovered-descendant mutation, see node-ops.ts header
+            // discovered-descendant mutation, see 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-ops.ts header
+            // discovered-descendant mutation, see node-primitives.ts header
             pushChild(targetItem, child);
         }
     }