@voithos-labs/aragonite 0.10.1

package/dist/tree-operations/reorder.js

@@ -0,0 +1,57 @@
+import { ensureUnsharedChild } from './unshare';
+import { absorbWindowSeams } from './node-ops';
+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.
+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}`);
+        return true;
+    }
+    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.
+export function reorderChildren(children, from, to) {
+    if (from === to)
+        return { op: 'noop' };
+    if (isReorderOutOfBounds(from, to, children.length))
+        return { op: 'noop' };
+    const lo = Math.min(from, to);
+    const hi = Math.max(from, to);
+    const count = hi - lo + 1;
+    const oldWindow = Array.from({ length: count }, (_, k) => lo + k);
+    const [movedOld] = oldWindow.splice(from - lo, 1);
+    oldWindow.splice(to - lo, 0, movedOld);
+    const [node] = children.splice(from, 1);
+    children.splice(to, 0, node);
+    const idMap = {};
+    for (let k = 0; k < count; k++)
+        idMap[k] = oldWindow[k] - lo;
+    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.
+ */
+export function reorderChildrenWithTrivia(children, from, to, sharing) {
+    if (from === to)
+        return { change: { op: 'noop' }, landing: to };
+    if (isReorderOutOfBounds(from, to, children.length)) {
+        return { change: { op: 'noop' }, landing: from };
+    }
+    const lo = Math.min(from, to);
+    const hi = Math.max(from, to);
+    const windowTrivia = [];
+    for (let i = lo; i <= hi; i++) {
+        windowTrivia.push(ensureUnsharedChild({ children }, i, sharing).leadingTrivia);
+    }
+    const change = reorderChildren(children, from, to);
+    for (let k = 0; k < windowTrivia.length; k++) {
+        children[lo + k].leadingTrivia = windowTrivia[k];
+    }
+    return absorbWindowSeams({ children }, lo, hi - lo + 1, to, change, sharing);
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Structural-sharing epoch primitive — the copy-on-write engine `unshare.ts` reads to
+ * decide when a node must be cloned before it is written. The undo lifecycle bumps the
+ * epoch, after which any node stamped earlier counts as shared. A missing `ownerEpoch`
+ * counts as shared too: an unnecessary copy is correct, a missed one corrupts history.
+ */
+export interface SharingState {
+    /** Bump after every snapshot push and every undo/redo restore. */
+    markSnapshotTaken(): void;
+    isShared(node: {
+        ownerEpoch?: number;
+    }): boolean;
+    /** Stamp a freshly created/copied node as owned by the live tree. */
+    stamp(node: {
+        ownerEpoch?: number;
+    }): void;
+}
+export declare function createSharingState(): SharingState;

package/dist/tree-operations/sharing.js

@@ -0,0 +1,14 @@
+export function createSharingState() {
+    let epoch = 0;
+    return {
+        markSnapshotTaken() {
+            epoch++;
+        },
+        isShared(node) {
+            return epoch > 0 && (node.ownerEpoch ?? -1) < epoch;
+        },
+        stamp(node) {
+            node.ownerEpoch = epoch;
+        }
+    };
+}

package/dist/tree-operations/splice-many.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The splice every mutation door owes a document-scaled list. A spread hands the engine one
+ * argument per item, and a list past its argument limit raises "Maximum call stack size exceeded"
+ * at the call (G4.60), so a list too long for one call goes in chunks. Splices in place, so the
+ * array keeps its identity and a `$state` proxy sees the writes a hand-rolled splice would make.
+ */
+/** Well under the engine's argument ceiling, which measures around 125,000 on a desktop V8. */
+export declare const INSERT_CHUNK = 50000;
+export declare function spliceMany<T>(target: T[], at: number, deleteCount: number, items: readonly T[]): void;

package/dist/tree-operations/splice-many.js

@@ -0,0 +1,22 @@
+/**
+ * The splice every mutation door owes a document-scaled list. A spread hands the engine one
+ * argument per item, and a list past its argument limit raises "Maximum call stack size exceeded"
+ * at the call (G4.60), so a list too long for one call goes in chunks. Splices in place, so the
+ * array keeps its identity and a `$state` proxy sees the writes a hand-rolled splice would make.
+ */
+/** Well under the engine's argument ceiling, which measures around 125,000 on a desktop V8. */
+export const INSERT_CHUNK = 50_000;
+export function spliceMany(target, at, deleteCount, items) {
+    // One call while the list fits in one: splitting the delete off costs a second O(n) shift of
+    // the tail, which every structural commit would pay over the document's id and ref arrays.
+    if (items.length <= INSERT_CHUNK) {
+        target.splice(at, deleteCount, ...items);
+        return;
+    }
+    // Splice's own start resolution, held fixed while the chunks shift the tail under it.
+    const start = at < 0 ? Math.max(target.length + at, 0) : Math.min(at, target.length);
+    target.splice(start, deleteCount);
+    for (let from = 0; from < items.length; from += INSERT_CHUNK) {
+        target.splice(start + from, 0, ...items.slice(from, from + INSERT_CHUNK));
+    }
+}

package/dist/tree-operations/structural-change.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Structural-change descriptor returned by tree ops; the commit primitive consumes it to
+ * auto-sync the parallel `blockIds` / `blockRefs` arrays, so callers never hand-splice
+ * them. Every variant describes ONE contiguous `at`/`count` window — an op editing two
+ * disjoint ranges splits into separate commits or uses the multi-scope commit path.
+ */
+import type { BlockComponent } from '../block-component';
+import type { CstNode } from '../core/nodes';
+import type { SharingState } from './sharing';
+export type StructuralChange = {
+    op: 'noop';
+} | {
+    op: 'insert';
+    at: number;
+    count: number;
+} | {
+    op: 'delete';
+    at: number;
+    count: number;
+} | {
+    op: 'replace';
+    at: number;
+    count: number;
+    newCount: number;
+    /** new-item index → old-item index: these new positions inherit old IDs/refs. */
+    idMap?: Record<number, number>;
+};
+/**
+ * Replace [at, at+count) where the FIRST new item inherits the old first item's id + ref,
+ * preserving Svelte keyed identity (cursor, IME composition) across the swap.
+ */
+export declare function replacePreservingFirst(at: number, count: number, newCount: number): StructuralChange;
+/**
+ * Stamp the nodes a change's insert/replace window CREATED as owned by the live tree;
+ * pre-existing nodes go through `unshare.ts` instead. Also backfills `childIds` on
+ * containers in a created subtree, before the commit publishes: a freshly-parsed node
+ * carries none, and under a reused component instance the nested keyed `{#each}` renders
+ * before the re-init effect, so undefined keys would reach Svelte.
+ */
+export declare function stampStructuralChange(children: CstNode[], change: StructuralChange, sharing: SharingState): void;
+/**
+ * Re-shape the parallel ids/refs arrays to match the mutated children. Inserts get fresh
+ * IDs + undefined refs; `idMap` on replace preserves specified old-index IDs.
+ */
+export declare function applyStructuralChangeToIdsRefs(change: StructuralChange, ids: string[], refs: (BlockComponent | undefined)[]): void;
+/** A parent whose parallel id array the splice doors maintain: a container, or the root. */
+type IdCarrier = {
+    children?: CstNode[];
+    childIds?: string[];
+};
+/**
+ * Borrow `parent.childIds` as the ledger the splice doors write their net splice into, so a
+ * caller running several of them reports what they add up to instead of re-deriving it from
+ * lengths (a settle's fold moves slots the caller's own window never named).
+ */
+export declare function trackChildIds(parent: IdCarrier): {
+    read: () => StructuralChange;
+    release: () => void;
+};
+/**
+ * The one contiguous change carrying `before` to `after`, read off slot identity: the matching
+ * ends fall outside the window, and every marker surviving inside it maps to where it stood.
+ */
+export declare function changeBetweenIds(before: readonly string[], after: readonly string[]): StructuralChange;
+export {};

package/dist/tree-operations/structural-change.js

@@ -0,0 +1,117 @@
+/**
+ * Structural-change descriptor returned by tree ops; the commit primitive consumes it to
+ * auto-sync the parallel `blockIds` / `blockRefs` arrays, so callers never hand-splice
+ * them. Every variant describes ONE contiguous `at`/`count` window — an op editing two
+ * disjoint ranges splits into separate commits or uses the multi-scope commit path.
+ */
+import { generateBlockId, assignChildIdsDeep, assignIds } from '../block-id';
+import { spliceMany } from './splice-many';
+import { assertInvariant } from '../assert';
+import { checkStructuralDescriptor } from '../invariants/structural-descriptor';
+/**
+ * Replace [at, at+count) where the FIRST new item inherits the old first item's id + ref,
+ * preserving Svelte keyed identity (cursor, IME composition) across the swap.
+ */
+export function replacePreservingFirst(at, count, newCount) {
+    return { op: 'replace', at, count, newCount, idMap: { 0: 0 } };
+}
+/**
+ * Stamp the nodes a change's insert/replace window CREATED as owned by the live tree;
+ * pre-existing nodes go through `unshare.ts` instead. Also backfills `childIds` on
+ * containers in a created subtree, before the commit publishes: a freshly-parsed node
+ * carries none, and under a reused component instance the nested keyed `{#each}` renders
+ * before the re-init effect, so undefined keys would reach Svelte.
+ */
+export function stampStructuralChange(children, change, sharing) {
+    if (change.op !== 'insert' && change.op !== 'replace')
+        return;
+    const count = change.op === 'insert' ? change.count : change.newCount;
+    for (let i = change.at; i < change.at + count; i++) {
+        sharing.stamp(children[i]);
+        assignChildIdsDeep(children[i]);
+    }
+}
+/**
+ * Re-shape the parallel ids/refs arrays to match the mutated children. Inserts get fresh
+ * IDs + undefined refs; `idMap` on replace preserves specified old-index IDs.
+ */
+export function applyStructuralChangeToIdsRefs(change, ids, refs) {
+    assertInvariant('structural-descriptor', () => checkStructuralDescriptor(change, ids.length));
+    switch (change.op) {
+        case 'noop':
+            return;
+        case 'insert': {
+            const newIds = Array.from({ length: change.count }, generateBlockId);
+            const newRefs = new Array(change.count).fill(undefined);
+            spliceMany(ids, change.at, 0, newIds);
+            spliceMany(refs, change.at, 0, newRefs);
+            return;
+        }
+        case 'delete': {
+            ids.splice(change.at, change.count);
+            refs.splice(change.at, change.count);
+            return;
+        }
+        case 'replace': {
+            const oldIds = ids.slice(change.at, change.at + change.count);
+            const oldRefs = refs.slice(change.at, change.at + change.count);
+            const idMap = change.idMap ?? {};
+            const newIds = Array.from({ length: change.newCount }, (_, i) => idMap[i] !== undefined ? oldIds[idMap[i]] : generateBlockId());
+            const newRefs = Array.from({ length: change.newCount }, (_, i) => idMap[i] !== undefined ? oldRefs[idMap[i]] : undefined);
+            spliceMany(ids, change.at, change.count, newIds);
+            spliceMany(refs, change.at, change.count, newRefs);
+            return;
+        }
+    }
+}
+/**
+ * Borrow `parent.childIds` as the ledger the splice doors write their net splice into, so a
+ * caller running several of them reports what they add up to instead of re-deriving it from
+ * lengths (a settle's fold moves slots the caller's own window never named).
+ */
+export function trackChildIds(parent) {
+    const had = parent.childIds;
+    const ids = had ?? assignIds(parent.children ?? []);
+    parent.childIds = ids;
+    const before = [...ids];
+    return {
+        read: () => changeBetweenIds(before, parent.childIds ?? []),
+        // A parent that kept no array keeps none: nothing else reconciles one it never had.
+        release: () => {
+            if (had === undefined)
+                parent.childIds = undefined;
+        }
+    };
+}
+/**
+ * The one contiguous change carrying `before` to `after`, read off slot identity: the matching
+ * ends fall outside the window, and every marker surviving inside it maps to where it stood.
+ */
+export function changeBetweenIds(before, after) {
+    const max = Math.min(before.length, after.length);
+    let at = 0;
+    while (at < max && before[at] === after[at])
+        at++;
+    let tail = 0;
+    while (tail < max - at && before[before.length - 1 - tail] === after[after.length - 1 - tail]) {
+        tail++;
+    }
+    const count = before.length - at - tail;
+    const newCount = after.length - at - tail;
+    if (count === 0 && newCount === 0)
+        return { op: 'noop' };
+    if (count === 0)
+        return { op: 'insert', at, count: newCount };
+    if (newCount === 0)
+        return { op: 'delete', at, count };
+    const oldSlotOf = new Map();
+    for (let i = 0; i < count; i++)
+        oldSlotOf.set(before[at + i], i);
+    const idMap = {};
+    for (let i = 0; i < newCount; i++) {
+        const oldSlot = oldSlotOf.get(after[at + i]);
+        if (oldSlot !== undefined)
+            idMap[i] = oldSlot;
+    }
+    return { op: 'replace', at, count, newCount, idMap };
+}

package/dist/tree-operations/sub-table-copy.d.ts

@@ -0,0 +1,6 @@
+import type { NodeView } from '../core/node-views';
+export interface CellPos {
+    rowIdx: number;
+    colIdx: number;
+}
+export declare function copyRectangleAsSubTable(table: NodeView, a: CellPos, b: CellPos): string;

package/dist/tree-operations/sub-table-copy.js

@@ -0,0 +1,43 @@
+import { metadataOf } from '../core/nodes';
+export function copyRectangleAsSubTable(table, a, b) {
+    const minRow = Math.min(a.rowIdx, b.rowIdx);
+    const maxRow = Math.max(a.rowIdx, b.rowIdx);
+    const minCol = Math.min(a.colIdx, b.colIdx);
+    const maxCol = Math.max(a.colIdx, b.colIdx);
+    const rows = table.children ?? [];
+    const cellRaws = [];
+    for (let r = minRow; r <= maxRow; r++) {
+        const rowCells = rows[r]?.children ?? [];
+        const slice = [];
+        for (let c = minCol; c <= maxCol; c++) {
+            slice.push(rowCells[c]?.raw ?? '');
+        }
+        cellRaws.push(slice);
+    }
+    if (cellRaws.length === 1 && cellRaws[0].length === 1) {
+        return cellRaws[0][0];
+    }
+    const alignments = metadataOf(table, 'table').alignments.slice(minCol, maxCol + 1);
+    const lines = [];
+    lines.push(formatRow(cellRaws[0]));
+    lines.push(formatRow(alignments.map(formatAlignmentCell)));
+    for (let i = 1; i < cellRaws.length; i++) {
+        lines.push(formatRow(cellRaws[i]));
+    }
+    return lines.join('');
+}
+function formatRow(cells) {
+    return '| ' + cells.join(' | ') + ' |\n';
+}
+function formatAlignmentCell(alignment) {
+    switch (alignment) {
+        case 'left':
+            return ':---';
+        case 'center':
+            return ':---:';
+        case 'right':
+            return '---:';
+        default:
+            return '---';
+    }
+}

package/dist/tree-operations/table-mutations.d.ts

@@ -0,0 +1,17 @@
+import type { CstNode, TableAlignment } from '../core/nodes';
+import type { StructuralChange } from './structural-change';
+export declare function insertEmptyRow(table: CstNode, rowIdx: number, side: 'above' | 'below'): void;
+export declare function insertEmptyColumn(table: CstNode, colIdx: number, side: 'left' | 'right'): StructuralChange[];
+export declare function deleteRow(table: CstNode, rowIdx: number): void;
+export declare function deleteColumn(table: CstNode, colIdx: number): StructuralChange[];
+export declare function moveColumn(table: CstNode, fromCol: number, toCol: number): StructuralChange[];
+export declare function setAlignment(table: CstNode, colIdx: number, alignment: TableAlignment): void;
+export declare function cycleAlignment(table: CstNode, colIdx: number): void;
+/**
+ * Whether a row delete is allowed. `rowCount` is the FULL count including the header. A
+ * header delete promotes the next row so it needs only a second row; a body delete needs
+ * a second body row, else it would leave a header-only table.
+ */
+export declare function canDeleteRow(rowIdx: number, rowCount: number): boolean;
+/** Whether a column delete is allowed: a table must keep at least one column. */
+export declare function canDeleteColumn(colCount: number): boolean;

package/dist/tree-operations/table-mutations.js

@@ -0,0 +1,101 @@
+// In-place table CST mutations; the caller owns the commit ceremony and the raw rebuild,
+// so these touch neither reactivity, undo, nor raw. Column mutators emit exactly one
+// StructuralChange per row, in row order, for multi-scope callers to pair with row scopes.
+import { metadataOf } from '../core/nodes';
+import { reorderChildren } from './reorder';
+const ALIGN_CYCLE = ['left', 'center', 'right'];
+// ── Public API ─────────────────────────────────────────────────────────────
+export function insertEmptyRow(table, rowIdx, side) {
+    const meta = metadataOf(table, 'table');
+    const newRow = {
+        kind: 'tableRow',
+        leadingTrivia: '',
+        raw: '',
+        metadata: { isHeader: false },
+        children: Array.from({ length: meta.columnCount }, () => ({
+            kind: 'tableCell',
+            leadingTrivia: '',
+            raw: ''
+        }))
+    };
+    const insertAt = side === 'above' ? rowIdx : rowIdx + 1;
+    table.children.splice(insertAt, 0, newRow);
+}
+export function insertEmptyColumn(table, colIdx, side) {
+    const meta = metadataOf(table, 'table');
+    const insertAt = side === 'left' ? colIdx : colIdx + 1;
+    const changes = [];
+    for (const row of table.children ?? []) {
+        row.children.splice(insertAt, 0, { kind: 'tableCell', leadingTrivia: '', raw: '' });
+        changes.push({ op: 'insert', at: insertAt, count: 1 });
+    }
+    meta.alignments.splice(insertAt, 0, 'none');
+    meta.columnCount += 1;
+    return changes;
+}
+// Unconditional: refusal (>=1 header + >=1 body row, >=1 column) is the wrapper's job.
+export function deleteRow(table, rowIdx) {
+    const rows = table.children ?? [];
+    const willRemoveHeader = rowIdx === 0;
+    rows.splice(rowIdx, 1);
+    if (willRemoveHeader && rows.length > 0) {
+        metadataOf(rows[0], 'tableRow').isHeader = true;
+    }
+}
+export function deleteColumn(table, colIdx) {
+    const meta = metadataOf(table, 'table');
+    const changes = [];
+    for (const row of table.children ?? []) {
+        row.children.splice(colIdx, 1);
+        changes.push({ op: 'delete', at: colIdx, count: 1 });
+    }
+    meta.alignments.splice(colIdx, 1);
+    meta.columnCount -= 1;
+    return changes;
+}
+// The per-row cell permute keeps keyed cell identity (reorderChildren's idMap); the
+// alignments splice must mirror that permutation exactly to stay in lockstep.
+export function moveColumn(table, fromCol, toCol) {
+    const meta = metadataOf(table, 'table');
+    const changes = [];
+    for (const row of table.children ?? []) {
+        changes.push(reorderChildren(row.children, fromCol, toCol));
+    }
+    if (fromCol !== toCol) {
+        const [moved] = meta.alignments.splice(fromCol, 1);
+        meta.alignments.splice(toCol, 0, moved);
+    }
+    return changes;
+}
+export function setAlignment(table, colIdx, alignment) {
+    metadataOf(table, 'table').alignments[colIdx] = alignment;
+}
+export function cycleAlignment(table, colIdx) {
+    const meta = metadataOf(table, 'table');
+    const current = meta.alignments[colIdx];
+    // 'none' renders identically to 'left', so stepping through it would look like a stuck
+    // press; jump to 'center' instead. Once cycling begins the column never re-enters it.
+    if (current === 'none') {
+        meta.alignments[colIdx] = 'center';
+        return;
+    }
+    const idx = ALIGN_CYCLE.indexOf(current);
+    meta.alignments[colIdx] = ALIGN_CYCLE[(idx + 1) % ALIGN_CYCLE.length];
+}
+// ── Delete-enablement predicates ─────────────────────────────────────────────
+// Single source of truth for the deletion-refusal rules, here rather than in
+// editor-actions/ so selection/ never has to reach across for them.
+/**
+ * Whether a row delete is allowed. `rowCount` is the FULL count including the header. A
+ * header delete promotes the next row so it needs only a second row; a body delete needs
+ * a second body row, else it would leave a header-only table.
+ */
+export function canDeleteRow(rowIdx, rowCount) {
+    if (rowCount <= 1)
+        return false;
+    return rowIdx === 0 || rowCount - 1 > 1;
+}
+/** Whether a column delete is allowed: a table must keep at least one column. */
+export function canDeleteColumn(colCount) {
+    return colCount > 1;
+}

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

@@ -0,0 +1,101 @@
+/**
+ * Copy-path-on-write for structural-sharing undo: unshare the root→target spine before
+ * any in-place write — undo entries still reference shared nodes. Copies are SHALLOW, so
+ * unshare deeper wherever you write. Write-then-re-read: after assigning a copy into the
+ * live tree, re-read it through the tree — the `$state` proxy wrapper is canonical, not
+ * the copy you held. Also the one sanctioned view→mutable door (`core/node-views.ts`).
+ */
+import type { CstNode } from '../core/nodes';
+import type { NodeParentView, NodeView } from '../core/node-views';
+import type { SharingState } from './sharing';
+import type { NodeParent, TrackedPosition } from './node-ops';
+import type { StructuralChange } from './structural-change';
+import { type ChildRawChange } from '../schema/child-spans';
+import type { GrammarView } from '../schema/block-openers';
+/**
+ * Unshare every node along `path` from `root`; returns the chain outermost-first.
+ * The caller owns `root.children` (live document, or a commit ceremony's array copy),
+ * which is what makes the splice safe.
+ */
+export declare function ensureUnsharedPath(root: NodeParentView, path: number[], sharing: SharingState): CstNode[];
+/**
+ * Unshare one direct child of an already-unshared parent — a node, or a
+ * caller-owned `{ children }` view (e.g. a commit ceremony's array copy).
+ */
+export declare function ensureUnsharedChild(parent: CstNode | NodeParent, index: number, sharing: SharingState): CstNode;
+/**
+ * Standalone copy for a node being MOVED out of a parent the snapshot keeps: the caller
+ * attaches the returned copy, the original stays in the old parent untouched. An
+ * unshared input passes through — unshared already means live-tree-owned.
+ */
+export declare function ensureUnsharedNode(node: NodeView, sharing: SharingState): CstNode;
+/** Unshare every direct child of an owned parent (e.g. table rows before a whole-table rebuild). */
+export declare function ensureUnsharedChildren(parent: CstNode, sharing: SharingState): void;
+/**
+ * Deep-unshare an owned node's subtree. Intended for small bounded subtrees
+ * (tables: rows + cells) ahead of ops that write at arbitrary depth.
+ */
+export declare function ensureUnsharedSubtree(node: CstNode, sharing: SharingState): void;
+/**
+ * Rebuild one owned container's raw. A grid rebuild rewrites its children's raw, so a
+ * grid's children are unshared first — keyed off `containerContract`, not a `table` kind
+ * test, or a plugin grid writes through shared children.
+ */
+export declare function rebuildOwnedContainer(node: CstNode, sharing: SharingState, changed?: ChildRawChange): void;
+/**
+ * Longest prefix of `chain` still attached under `root`, identity-checked level by level.
+ * A commit mutation can splice a node out mid-ceremony; rebuilding the detached node's
+ * raw against its emptied children writes `raw: ''` and trips the commit-time staleness
+ * check. Ancestors above the detachment still need their rebuild — hence prefix.
+ */
+export declare function attachedChainPrefix(root: NodeParent, chain: CstNode[]): CstNode[];
+/**
+ * One container slot a rebuild re-kinded. `previous` is the rollback register: a commit
+ * unwinding after the swap has already published `replacement` into a live children
+ * array, which no other rollback register reaches.
+ */
+export interface ContainerReclassification {
+    siblings: CstNode[];
+    index: number;
+    previous: CstNode;
+    replacement: CstNode;
+}
+/**
+ * A fold the rebuilt container's own slot owed: its bytes stopped interrupting a neighbour, so
+ * the parent's array reloads as fewer blocks and no scope-local settle reaches that join
+ * `before` is the pre-splice array — the rollback register, since the splice lands in
+ * an array no commit descriptor covers. `landing` is where the container's first byte ended up.
+ */
+export interface AncestrySeamFold {
+    /** Chain level of the folded container, so a caller composes the owner's path from its own. */
+    depth: number;
+    siblings: CstNode[];
+    /** The chain node owning `siblings`, or null when they are the rebuild root's children. */
+    owner: CstNode | null;
+    change: StructuralChange;
+    before: CstNode[];
+    landing: TrackedPosition;
+}
+/**
+ * What the typing door knows and a bare chain does not: where the chain sits in the document,
+ * and the bytes its leaf carried before the write. Both are guesses the rebuild identity-checks.
+ */
+export interface ChainWriteHint {
+    path: number[];
+    leafPreviousRaw: string;
+}
+/**
+ * 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; the re-derive additionally needs
+ * `lineOpensAs` not to name the current kind, a positive identification so a declining opener
+ * parses rather than eliding a real kind change. `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 declare function rebuildUnsharedChain(root: NodeParent | CstNode, chain: CstNode[], sharing: SharingState, folds: AncestrySeamFold[] | null, grammar: GrammarView | undefined, hint?: ChainWriteHint): ContainerReclassification[];
+/**
+ * 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 declare function rebuildUnsharedAncestry(root: NodeParent, path: number[], sharing: SharingState, folds: AncestrySeamFold[] | null, grammar: GrammarView | undefined): ContainerReclassification[];