@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/selection/range-delete-ceremony.d.ts

@@ -1,85 +1,39 @@
 /**
- * Deletion ceremony shared by every rangeDelete branch (generic, chrome, table): covered paths
- * splice identity-gated in reverse doc order, with cascading empty-ancestor cleanup. The wall
- * branches also reduce covered paths to subtree roots so a container dies as ONE splice with
- * children intact, keeping a commit scope or undo entry holding the detached node clean.
+ * The deletion steps every `rangeDelete` branch shares: the subtrees `rangeCoverage` holds whole
+ * are spliced out in reverse document order, each only while it still holds the node captured up
+ * front, then every ancestor left empty goes, up to the document. A kept edge is truncated and
+ * reinstalled the way a reload would parse it.
  */
 import type { GrammarView } from '../schema/block-openers';
-import type { PresentationMode } from '../presentation-mode';
-import type { InlineResolverRef } from '../schema/inline-construct-policy';
+import type { Reading } from '../schema/reading';
 import type { CstNode, Document } from '../core/nodes';
 import type { SelectionPoint } from './primitives';
+import { type RangeCoverage } from './range-coverage';
 import type { SharingState } from '../tree-operations/sharing';
-import { type ChromeContainer } from './range-delete-chrome';
-/**
- * Identity-gated reverse-doc-order deletion: a deeper delete + cascade can shift a survivor
- * into an outer slot, so each path is re-resolved and spliced only while it still holds the
- * node captured up front. Caller must own every parent spine BEFORE calling (G1.9).
- */
-export declare function deleteSubtreesIdentityGated(doc: Document, deletionPaths: number[][], lcaPath: number[], sharing: SharingState): void;
-/** The live-seam reads a prose truncation needs; both undefined outside live. */
-export interface LiveSeamContext {
-    presentationMode: PresentationMode | undefined;
-    linkRef: InlineResolverRef | undefined;
-}
-/**
- * Reparse the bytes surviving at an endpoint's slot, through the source kind's own write rule:
- * the reparse re-derives metadata from bytes, so structure the truncation dropped and the rule
- * restores (a fence closer) has to land before it. The slot's leading trivia rides across, and
- * an empty slice gives a bare paragraph, on the source block's line ending (G4.20).
- */
-export declare function reparseTruncatedEndpoint(node: CstNode, slice: string): CstNode[];
-/**
- * Install an endpoint's replacement, stamped as the live tree's own. The splice door settles the
- * blank run a truncation left the slot in (G2.13); `sharing` owns the writes.
- */
-export declare function installTruncatedEndpoint(doc: Document, path: number[], replacement: CstNode[], sharing: SharingState): void;
-/**
- * Truncate the start endpoint in place, after the planned deletion: a chrome start keeps its
- * bytes literal by raw write; a prose head crosses the unpaired-run cleanup, then reinstalls
- * through the endpoint reparse. Returns the seam the collapsed caret lands on. `isChrome` is
- * the caller's own derivation, read before any splice moved the tree.
- */
-export declare function truncateStartInPlace(doc: Document, start: SelectionPoint, startBlock: CstNode, isChrome: boolean, live: LiveSeamContext, sharing: SharingState, tag: string): number;
-/**
- * Truncate the end endpoint in place, before the planned deletion (its path is still live):
- * chrome by raw write, prose through the cleanup + reparse. Returns the surviving tail node
- * re-read through the tree (design rule 5), for a caller that must locate it after splices.
- */
-export declare function truncateEndInPlace(doc: Document, end: SelectionPoint, endBlock: CstNode, isChrome: boolean, live: LiveSeamContext, sharing: SharingState, tag: string): CstNode | null;
-export interface EndWall {
-    container: ChromeContainer;
-    consumed: boolean;
-}
-/**
- * End-side wall context: the chrome container holding the end point, when the range enters it
- * from outside. `consumed` means the whole subtree is covered (a prose end's last-byte rule, or
- * an emptied table on the container's last-child chain), so the container unit-deletes.
- */
-export declare function resolveEndWall(doc: Document, start: SelectionPoint, end: SelectionPoint, endTableEmptied: boolean | null): EndWall | null;
+/** Installs `bytes` at `path` as a reload reads them there, through `source`'s write rule, keeping
+ *  its leading blank lines and the task-marker rule; returns the caret shift a marker takes. */
+export declare function installSurvivor(doc: Document, path: number[], source: CstNode, bytes: string, sharing: SharingState, reading: Reading): number;
+/** Truncates the start endpoint in place, after the planned deletion, and returns the caret's
+ *  offset. `isChrome` must be read before any splice moved the tree. */
+export declare function truncateStartInPlace(doc: Document, start: SelectionPoint, startBlock: CstNode, isChrome: boolean, reading: Reading, sharing: SharingState, tag: string): number;
+/** Truncates the end endpoint in place, before the planned deletion while its path is valid,
+ *  and returns the surviving tail as re-read through the tree, never the raw copy. */
+export declare function truncateEndInPlace(doc: Document, end: SelectionPoint, endBlock: CstNode, isChrome: boolean, reading: Reading, sharing: SharingState, tag: string): CstNode | null;
 export interface DeletionPlan {
     deletionPaths: number[][];
+    /** Each deletion path's parent chain, copied before any splice, for the rebuild after it. */
+    parentChains: CstNode[][];
     chromeClearChain: CstNode[] | null;
-    /** The epoch the plan was collected against; the apply step's splices own their
-     *  spines through it, so no case has to re-thread it. */
+    /** The sharing state the plan was collected against; the apply step's splices copy their
+     *  chains through it, so no branch has to pass it again. */
     sharing: SharingState;
 }
-/**
- * Plan the deletion via {@link collectDeletionPlan}, own every deletion path's parent spine
- * before any splice (G1.9), and resolve the LCA cascade cleanup stops at. The caller resolves
- * `wall` itself: its `consumed` flag also gates each case's endpoint prose-replace.
- */
-export declare function planCrossBlockDeletion(doc: Document, start: SelectionPoint, end: SelectionPoint, endpointPaths: number[][], wall: EndWall | null, sharing: SharingState): {
-    plan: DeletionPlan;
-    lcaPath: number[];
-};
-/**
- * Apply the plan atomically: clear a surviving end container's covered chrome (raw write, never
- * a node delete), then splice the covered subtrees in reverse doc order under the identity gate.
- */
-export declare function applyPlannedDeletion(doc: Document, plan: DeletionPlan, lcaPath: number[]): void;
-/**
- * Rebuild every deletion path's surviving ancestry, then the cleared chrome's opener line
- * (chain-based, so the re-emit survives the splices). Case-specific rebuilds stay at call sites.
- */
-export declare function rebuildSharedAncestries(doc: Document, plan: DeletionPlan, sharing: SharingState, grammar: GrammarView | undefined): void;
+/** Plans removing every subtree `coverage` holds whole, plus `alsoRemoved` (an end block whose
+ *  tail joined the start); a covered title row is cleared instead, so it stays child 0. */
+export declare function planCrossBlockDeletion(doc: Document, coverage: RangeCoverage, alsoRemoved: number[][], sharing: SharingState): DeletionPlan;
+/** Applies the plan: clears a surviving end container's covered title line (a raw write, never a
+ *  node delete), then splices the covered subtrees. */
+export declare function applyPlannedDeletion(doc: Document, plan: DeletionPlan, grammar: GrammarView): void;
+/** Rebuilds what is still attached of each removed subtree's parent chain, then the cleared title
+ *  line's container, so every surviving container re-emits its raw. */
+export declare function rebuildSharedAncestries(doc: Document, plan: DeletionPlan, sharing: SharingState, grammar: GrammarView): void;

package/dist/selection/range-delete-ceremony.js

@@ -1,33 +1,27 @@
 /**
- * Deletion ceremony shared by every rangeDelete branch (generic, chrome, table): covered paths
- * splice identity-gated in reverse doc order, with cascading empty-ancestor cleanup. The wall
- * branches also reduce covered paths to subtree roots so a container dies as ONE splice with
- * children intact, keeping a commit scope or undo entry holding the detached node clean.
+ * The deletion steps every `rangeDelete` branch shares: the subtrees `rangeCoverage` holds whole
+ * are spliced out in reverse document order, each only while it still holds the node captured up
+ * front, then every ancestor left empty goes, up to the document. A kept edge is truncated and
+ * reinstalled the way a reload would parse it.
  */
-import { parse } from '../core/parser';
-import { displayLength, terminateLine, trailingLineEnding } from '../core/lines';
-import { charOffsetOf, walkBetween } from './primitives';
-import { comparePaths, isStrictAncestorOf, isPathSubtreeBetween, lowestCommonAncestor, pathHasPrefix, pathsEqual } from './path-math';
+import { nearestChromeContainer } from './range-coverage';
+import { displayLength, documentLineEnding, terminateLine, trailingLineEnding } from '../core/lines';
+import { charOffsetOf } from './primitives';
+import { comparePaths, pathHasPrefix, pathsEqual } from './path-math';
 import { cascadeCleanupEmptyAncestors } from '../tree-operations/cleanup';
 import { deleteAtPath, replaceAtPath } from '../tree-operations/path-mutate';
 import { blockNodeAt, emptyParagraph, nodeAt, normalizeOwnRaw } from '../tree-operations/node-primitives';
-import { cleanJoinedRaw } from '../tree-operations/node-ops';
+import { cleanJoinedRaw } from '../tree-operations/leaf-range';
+import { storedAsAt } from '../tree-operations/stored-as';
+import { cutBeforeSuffix } from '../tree-operations/structural-suffix';
+import { structuralSuffix } from '../core/inline';
 import { ensureUnsharedPath } from '../tree-operations/unshare';
-import { rebuildUnsharedAncestry, rebuildUnsharedChain } from '../tree-operations/chain-rebuild';
-// Wall primitives live with the chrome branch, which imports the atoms below back. The
-// resulting cycle is function-body-only (resolved at call time, never at module load), so it
-// is safe.
-import { nearestChromeContainer, rangeConsumesContainer, lastChildDescendant } from './range-delete-chrome';
-/** Subtree roots only: one splice per covered subtree, never a child-by-child emptying. */
-function filterToSubtreeRoots(paths) {
-    return paths.filter((p) => !paths.some((q) => isStrictAncestorOf(q, p)));
-}
-/**
- * Identity-gated reverse-doc-order deletion: a deeper delete + cascade can shift a survivor
- * into an outer slot, so each path is re-resolved and spliced only while it still holds the
- * node captured up front. Caller must own every parent spine BEFORE calling (G1.9).
- */
-export function deleteSubtreesIdentityGated(doc, deletionPaths, lcaPath, sharing) {
+import { attachedChainPrefix, rebuildUnsharedChain } from '../tree-operations/chain-rebuild';
+import { slotReaderAt } from '../tree-operations/list/task-paragraph';
+import { taskMarkerCaretShift, writeKeepingTaskMarker } from '../tree-operations/list/reconcile-task';
+/** Deletes in reverse order, each path only while it holds its captured node (cleanup can move a
+ *  survivor there); the caller copies parent chains first so the check compares copies (G1.9). */
+function deleteSubtreesIdentityGated(doc, deletionPaths, sharing, grammar) {
     const targetNodes = deletionPaths.map((p) => nodeAt(doc, p));
     const reverseSortedIndices = deletionPaths
         .map((_, i) => i)
@@ -35,18 +29,14 @@ export function deleteSubtreesIdentityGated(doc, deletionPaths, lcaPath, sharing
     for (const i of reverseSortedIndices) {
         const path = deletionPaths[i];
         if (nodeAt(doc, path) === targetNodes[i]) {
-            deleteAtPath(doc, path, sharing);
-            cascadeCleanupEmptyAncestors(doc, path, lcaPath, sharing);
+            deleteAtPath(doc, path, sharing, grammar);
+            cascadeCleanupEmptyAncestors(doc, path, sharing, grammar);
         }
     }
 }
-/**
- * A wall-branch truncation is half a join: the runs it strands, their partner gone with the
- * cut, are bytes the reader never saw, so a kept prose side crosses the registered cleaner
- * (live-mode.md § 4.5), expressed as a join with the block's own edge. Identity outside live;
- * a chrome child's raw write never routes here — the wall stays byte-literal.
- */
-function cleanTruncatedProse(node, kept, cut, live) {
+/** A truncation is half a join, so in live mode the kept text drops unpaired delimiter runs:
+ *  `docs/design/live-mode.md` § 4.5 Joins clean up where they meet. */
+function cleanTruncatedProse(node, kept, cut, store) {
     const join = kept === 'head'
         ? {
             mergedRaw: node.raw.slice(0, cut),
@@ -60,140 +50,109 @@ function cleanTruncatedProse(node, kept, cut, live) {
             start: { node, offset: 0 },
             end: { node, offset: cut }
         };
-    return cleanJoinedRaw({ ...join, linkRef: live.linkRef }, live.presentationMode);
+    return cleanJoinedRaw({ ...join, typed: '', store });
 }
-/**
- * Reparse the bytes surviving at an endpoint's slot, through the source kind's own write rule:
- * the reparse re-derives metadata from bytes, so structure the truncation dropped and the rule
- * restores (a fence closer) has to land before it. The slot's leading trivia rides across, and
- * an empty slice gives a bare paragraph, on the source block's line ending (G4.20).
- */
-export function reparseTruncatedEndpoint(node, slice) {
-    const lineEnding = trailingLineEnding(node.raw);
-    const reparsed = parse(normalizeOwnRaw(node, slice) || lineEnding, { scope: 'fragment' });
-    if (reparsed.children.length === 0) {
-        return [emptyParagraph(node.leadingTrivia, lineEnding)];
+/** Installs `bytes` at `path` as a reload reads them there, through `source`'s write rule, keeping
+ *  its leading blank lines and the task-marker rule; returns the caret shift a marker takes. */
+export function installSurvivor(doc, path, source, bytes, sharing, reading) {
+    const ending = documentLineEnding(doc);
+    const lineEnding = trailingLineEnding(source.raw, ending);
+    const written = normalizeOwnRaw(source, bytes, ending) || lineEnding;
+    const reparsed = slotReaderAt(doc, path, reading.grammar)(written);
+    const replacement = reparsed.children.slice();
+    if (replacement.length === 0) {
+        replacement.push(emptyParagraph(source.leadingTrivia, lineEnding));
     }
-    const cloned = reparsed.children.slice();
-    cloned[0] = { ...cloned[0], leadingTrivia: node.leadingTrivia };
-    // The peeled trailing blank line has no follower slot here, so it stays in raw.
-    cloned[cloned.length - 1].raw += reparsed.suffix;
-    return cloned;
-}
-/**
- * Install an endpoint's replacement, stamped as the live tree's own. The splice door settles the
- * blank run a truncation left the slot in (G2.13); `sharing` owns the writes.
- */
-export function installTruncatedEndpoint(doc, path, replacement, sharing) {
-    for (const node of replacement)
-        sharing.stamp(node);
-    replaceAtPath(doc, path, replacement, sharing);
+    else {
+        replacement[0] = { ...replacement[0], leadingTrivia: source.leadingTrivia };
+        // The trailing blank line the parser split off has no following block to attach to here,
+        // so it stays in raw.
+        replacement[replacement.length - 1].raw += reparsed.suffix;
+    }
+    const owner = blockNodeAt(doc, path.slice(0, -1)) ?? undefined;
+    const slot = path[path.length - 1];
+    const shift = slot === 0 && owner ? taskMarkerCaretShift(owner, written) : 0;
+    const siblings = (owner ?? doc).children ?? [];
+    // `replaceAtPath` fixes the blank lines around it so the tree reparses the same (G2.13).
+    writeKeepingTaskMarker(owner, siblings, slot, sharing, () => {
+        for (const node of replacement)
+            sharing.stamp(node);
+        replaceAtPath(doc, path, replacement, sharing, reading.grammar);
+    });
+    return shift;
 }
-/**
- * Truncate the start endpoint in place, after the planned deletion: a chrome start keeps its
- * bytes literal by raw write; a prose head crosses the unpaired-run cleanup, then reinstalls
- * through the endpoint reparse. Returns the seam the collapsed caret lands on. `isChrome` is
- * the caller's own derivation, read before any splice moved the tree.
- */
-export function truncateStartInPlace(doc, start, startBlock, isChrome, live, sharing, tag) {
+/** Truncates the start endpoint in place, after the planned deletion, and returns the caret's
+ *  offset. `isChrome` must be read before any splice moved the tree. */
+export function truncateStartInPlace(doc, start, startBlock, isChrome, reading, sharing, tag) {
     const cut = charOffsetOf(start, tag);
-    const head = isChrome
-        ? { raw: startBlock.raw.slice(0, cut), seam: cut }
-        : cleanTruncatedProse(startBlock, 'head', cut, live);
+    const ending = documentLineEnding(doc);
+    const lineEnding = trailingLineEnding(startBlock.raw, ending);
     if (isChrome) {
-        startBlock.raw = terminateLine(head.raw, startBlock.raw);
+        startBlock.raw = terminateLine(startBlock.raw.slice(0, cut), lineEnding);
+        return cut;
     }
-    else {
-        installTruncatedEndpoint(doc, start.path, reparseTruncatedEndpoint(startBlock, terminateLine(head.raw, startBlock.raw)), sharing);
-    }
-    return head.seam;
+    // The kept head keeps the block's structure after it (a setext underline), as a join does.
+    const head = cleanTruncatedProse(startBlock, 'head', cutBeforeSuffix(startBlock, cut), storedAsAt(doc, start.path, reading));
+    const kept = terminateLine(head.raw + structuralSuffix(startBlock), lineEnding);
+    const shift = installSurvivor(doc, start.path, startBlock, kept, sharing, reading);
+    return Math.max(0, head.seam + shift);
 }
-/**
- * Truncate the end endpoint in place, before the planned deletion (its path is still live):
- * chrome by raw write, prose through the cleanup + reparse. Returns the surviving tail node
- * re-read through the tree (design rule 5), for a caller that must locate it after splices.
- */
-export function truncateEndInPlace(doc, end, endBlock, isChrome, live, sharing, tag) {
+/** Truncates the end endpoint in place, before the planned deletion while its path is valid,
+ *  and returns the surviving tail as re-read through the tree, never the raw copy. */
+export function truncateEndInPlace(doc, end, endBlock, isChrome, reading, sharing, tag) {
     const cut = charOffsetOf(end, tag);
     if (isChrome) {
-        endBlock.raw = endBlock.raw.slice(cut) || trailingLineEnding(endBlock.raw);
+        endBlock.raw =
+            endBlock.raw.slice(cut) || trailingLineEnding(endBlock.raw, documentLineEnding(doc));
         return endBlock;
     }
-    const tail = cleanTruncatedProse(endBlock, 'tail', cut, live).raw;
-    installTruncatedEndpoint(doc, end.path, reparseTruncatedEndpoint(endBlock, tail), sharing);
+    const tail = cleanTruncatedProse(endBlock, 'tail', cut, storedAsAt(doc, end.path, reading)).raw;
+    installSurvivor(doc, end.path, endBlock, tail, sharing, reading);
     return blockNodeAt(doc, end.path);
 }
-/**
- * End-side wall context: the chrome container holding the end point, when the range enters it
- * from outside. `consumed` means the whole subtree is covered (a prose end's last-byte rule, or
- * an emptied table on the container's last-child chain), so the container unit-deletes.
- */
-export function resolveEndWall(doc, start, end, endTableEmptied) {
-    const container = nearestChromeContainer(doc, end.path);
-    if (!container || pathHasPrefix(start.path, container.path))
-        return null;
-    const consumed = endTableEmptied === null
-        ? rangeConsumesContainer(container, end)
-        : endTableEmptied && lastChildDescendant(container, end.path) !== null;
-    return { container, consumed };
-}
-/**
- * Covered subtree roots plus endpoint paths the caller marks for removal, honoring the chrome
- * wall: a surviving end container's covered chrome CLEARS instead of deleting (returned as an
- * unshared chain for the caller's raw write), and a consumed container becomes one unit delete.
- */
-function collectDeletionPlan(doc, start, end, endpointPaths, wall, sharing) {
-    const between = walkBetween(doc, start.path, end.path).filter((p) => isPathSubtreeBetween(p, start.path, end.path));
-    const chromeClearPath = wall && !wall.consumed ? [...wall.container.path, 0] : null;
+/** Plans removing every subtree `coverage` holds whole, plus `alsoRemoved` (an end block whose
+ *  tail joined the start); a covered title row is cleared instead, so it stays child 0. */
+export function planCrossBlockDeletion(doc, coverage, alsoRemoved, sharing) {
+    const clearPath = titleRowToClear(doc, coverage.range);
     let chromeClearChain = null;
-    let candidates = [];
-    for (const p of between) {
-        if (chromeClearPath && pathsEqual(p, chromeClearPath)) {
-            const chain = ensureUnsharedPath(doc, p, sharing);
-            if (chain.length === p.length)
+    const deletionPaths = [];
+    for (const root of coverage.wholeRoots) {
+        if (clearPath && pathsEqual(root, clearPath)) {
+            const chain = ensureUnsharedPath(doc, root, sharing);
+            if (chain.length === root.length)
                 chromeClearChain = chain;
         }
         else {
-            candidates.push(p);
+            deletionPaths.push(root.slice());
         }
     }
-    candidates.push(...endpointPaths);
-    if (wall?.consumed) {
-        candidates = candidates.filter((p) => !pathHasPrefix(p, wall.container.path));
-        candidates.push(wall.container.path.slice());
-    }
-    return { deletionPaths: filterToSubtreeRoots(candidates), chromeClearChain, sharing };
+    deletionPaths.push(...alsoRemoved.map((path) => path.slice()));
+    const parentChains = deletionPaths.map((path) => ensureUnsharedPath(doc, path.slice(0, -1), sharing));
+    return { deletionPaths, parentChains, chromeClearChain, sharing };
 }
-/**
- * Plan the deletion via {@link collectDeletionPlan}, own every deletion path's parent spine
- * before any splice (G1.9), and resolve the LCA cascade cleanup stops at. The caller resolves
- * `wall` itself: its `consumed` flag also gates each case's endpoint prose-replace.
- */
-export function planCrossBlockDeletion(doc, start, end, endpointPaths, wall, sharing) {
-    const plan = collectDeletionPlan(doc, start, end, endpointPaths, wall, sharing);
-    for (const path of plan.deletionPaths) {
-        ensureUnsharedPath(doc, path.slice(0, -1), sharing);
-    }
-    return { plan, lcaPath: lowestCommonAncestor(start.path, end.path) };
-}
-/**
- * Apply the plan atomically: clear a surviving end container's covered chrome (raw write, never
- * a node delete), then splice the covered subtrees in reverse doc order under the identity gate.
- */
-export function applyPlannedDeletion(doc, plan, lcaPath) {
+/** Applies the plan: clears a surviving end container's covered title line (a raw write, never a
+ *  node delete), then splices the covered subtrees. */
+export function applyPlannedDeletion(doc, plan, grammar) {
     const chrome = plan.chromeClearChain?.[plan.chromeClearChain.length - 1];
     if (chrome)
         chrome.raw = '\n';
-    deleteSubtreesIdentityGated(doc, plan.deletionPaths, lcaPath, plan.sharing);
+    deleteSubtreesIdentityGated(doc, plan.deletionPaths, plan.sharing, grammar);
 }
-/**
- * Rebuild every deletion path's surviving ancestry, then the cleared chrome's opener line
- * (chain-based, so the re-emit survives the splices). Case-specific rebuilds stay at call sites.
- */
+/** Rebuilds what is still attached of each removed subtree's parent chain, then the cleared title
+ *  line's container, so every surviving container re-emits its raw. */
 export function rebuildSharedAncestries(doc, plan, sharing, grammar) {
-    for (const path of plan.deletionPaths) {
-        rebuildUnsharedAncestry(doc, path, sharing, null, grammar);
+    for (const chain of plan.parentChains) {
+        const attached = attachedChainPrefix(doc, chain);
+        if (attached.length > 0)
+            rebuildUnsharedChain(doc, attached, sharing, null, grammar);
     }
     if (plan.chromeClearChain)
         rebuildUnsharedChain(doc, plan.chromeClearChain, sharing, null, grammar);
 }
+/** The title row of the title-line container holding the end, when the start is outside it. */
+function titleRowToClear(doc, range) {
+    const container = nearestChromeContainer(doc, range.end.path);
+    if (!container || pathHasPrefix(range.start.path, container.path))
+        return null;
+    return [...container.path, 0];
+}

package/dist/selection/range-delete-chrome.d.ts

@@ -1,39 +1,26 @@
 /**
- * Reserved-chrome branch of rangeDelete, the wall rule: nothing merges across a
- * `reservedChrome` container's wall. Outside endpoints truncate in place, covered chrome clears
- * (never node-deletes, G1.14), covered body children delete, and the container dies only when
- * the range consumes its whole subtree, then as ONE splice with children intact.
+ * The `rangeDelete` branch where nothing merges: an endpoint in a container with a title row (a
+ * details block's summary line) the range crosses, or an edge the range holds whole. Each kept edge
+ * is truncated in place. A covered title line is cleared, not deleted, so the title leaf stays at
+ * child 0 (G1.14).
  */
-import type { GrammarView } from '../schema/block-openers';
-import type { PresentationMode } from '../presentation-mode';
-import type { InlineResolverRef } from '../schema/inline-construct-policy';
-import type { CstNode, Document } from '../core/nodes';
+import type { Reading } from '../schema/reading';
+import type { Document } from '../core/nodes';
+import type { DocumentView } from '../core/node-views';
 import type { SelectionPoint } from './primitives';
 import type { RangeDeleteResult } from './range-delete';
+import { type RangeCoverage } from './range-coverage';
 import type { SharingState } from '../tree-operations/sharing';
-/**
- * True when the range must take the wall path: an endpoint sits inside a `reservedChrome`
- * container the range crosses out of or into, or the range starts in the chrome leaf itself.
- * Same-block, body-only, and enclose-from-outside ranges stay on the generic path.
- */
+import { type RemovalGesture } from './caret-target';
+/** Whether an endpoint sits inside a title-line container the range crosses into or out of, or
+ *  the range starts on the title line itself. */
 export declare function involvesReservedChrome(doc: Document, start: SelectionPoint, end: SelectionPoint): boolean;
-/**
- * Delete [start, end] under the wall rule. Both endpoints truncate in place (chrome by a raw
- * write, keeping the kind via contextDependentKind; prose by a reparse of the surviving slice),
- * and nothing merges across the wall. Collapsed caret keeps generic start-position semantics.
- */
-export declare function chromeAwareRangeDelete(doc: Document, start: SelectionPoint, end: SelectionPoint, sharing: SharingState, grammar: GrammarView | undefined, presentationMode?: PresentationMode, linkRef?: InlineResolverRef): RangeDeleteResult;
-export interface ChromeContainer {
-    path: number[];
-    node: CstNode;
-}
-/** Deepest strict ancestor of `path` whose kind declares reservedChrome. */
-export declare function nearestChromeContainer(doc: Document, path: number[]): ChromeContainer | null;
-export declare function isChromeChild(container: ChromeContainer, leafPath: number[]): boolean;
-/**
- * The range's end lands on the container's last byte: every step from the container is a
- * last-child edge and the offset consumes the block's visible text.
- */
-export declare function rangeConsumesContainer(container: ChromeContainer, end: SelectionPoint): boolean;
-/** The node at `path` when every step from the container is a last-child edge, else null. */
-export declare function lastChildDescendant(container: ChromeContainer, path: number[]): CstNode | null;
+/** Deletes what the range covers with no merge: removes what it holds whole and truncates each kept
+ *  edge in place. `gesture` lands the caret when the range keeps neither edge. */
+export declare function unjoinedRangeDelete(doc: Document, coverage: RangeCoverage, sharing: SharingState, reading: Reading, gesture: RemovalGesture): RangeDeleteResult;
+/** The caret once the block at `path` went, on the side `gesture` points; read on the committed
+ *  tree, which holds the block the commit gives an emptied document. */
+export declare function caretWhereRemoved(committed: DocumentView, path: number[], gesture: RemovalGesture): SelectionPoint | null;
+/** The caret once a range took the block at `path` whole and ran on: where what's left of the
+ *  range's end begins, read on the committed tree. */
+export declare function caretWhereRangeResumes(committed: DocumentView, path: number[]): SelectionPoint | null;