@voithos-labs/aragonite 0.10.2 → 0.10.3

package/dist/styles/editor.css

@@ -168,6 +168,29 @@
 	max-width: 100%;
 	height: auto;
 	display: block;
+	/* Enough to take the hard corner off a photo sitting in prose, not enough to read as a
+	   card: half the surface radius the block chrome uses. */
+	border-radius: 4px;
+}
+
+/* A cropped image: the widget is the frame (width and aspect set inline from the `|WxH` hint,
+   capped to the column) and the image pans inside it, sized and offset by `image-crop.ts`. */
+:where(.editor) .md-image-widget.md-image-cropped {
+	overflow: hidden;
+	max-width: 100%;
+	/* The frame clips the picture, so the rounding belongs to it; the picture inside is square
+	   again or its own corners would cut inside the frame's. */
+	border-radius: 4px;
+}
+
+:where(.editor) .md-image-widget.md-image-cropped img {
+	border-radius: 0;
+}
+
+:where(.editor) .md-image-widget.md-image-cropped img {
+	position: absolute;
+	max-width: none;
+	object-fit: cover;
 }
 
 /* Image-bearing list-item / blockquote paragraph: the ambient marker sits at the image's
@@ -249,6 +272,12 @@
 	pointer-events: none;
 }
 
+/* The tint IS the widget's selection paint: native `::selection` on the text inside it (a KaTeX
+   box is text) would stack a second wash on the same pixels. */
+:where(.editor) [data-inline-widget].md-widget-selected ::selection {
+	background: transparent;
+}
+
 /* Synthetic caret on the snap-target edge — Chromium doesn't reliably render
    the live caret adjacent to a contenteditable=false neighbor. */
 :where(.editor) [data-inline-widget].md-snap-after::before,
@@ -263,12 +292,14 @@
 	pointer-events: none;
 }
 
+/* Clear of the widget's own edge: against a picture, a caret drawn tight to the frame reads as
+   part of the border rather than as a caret waiting for the next character. */
 :where(.editor) [data-inline-widget].md-snap-after::before {
-	right: -2px;
+	right: -4px;
 }
 
 :where(.editor) [data-inline-widget].md-snap-before::before {
-	left: -2px;
+	left: -4px;
 }
 
 @keyframes md-snap-caret-blink {
@@ -350,7 +381,7 @@
 /* Dimmed monospace gives inline raw HTML a code-ish feel without becoming a code span. */
 :where(.editor) .md-raw-html {
 	color: var(--md-raw-html-color, rgba(120, 120, 120, 0.85));
-	font-family: var(--font-editor, ui-monospace, monospace);
+	font-family: var(--font-code, ui-monospace, monospace);
 	font-size: 0.92em;
 }
 
@@ -367,7 +398,7 @@
 	width: 100%;
 	box-sizing: border-box;
 	min-height: 1.4em;
-	font-family: var(--font-editor, ui-monospace, monospace);
+	font-family: var(--font-code, ui-monospace, monospace);
 	font-size: 0.9em;
 	line-height: 1.5;
 	color: inherit;
@@ -394,6 +425,13 @@
 	color: var(--syntax-code, currentColor);
 }
 
+/* An inline widget's source while it is revealed for editing (`$x$`, a footnote ref): the
+   inline-code wash, so the span being edited reads as a span, in the prose face so the line
+   does not reflow around it. */
+::highlight(md-inline-reveal) {
+	background-color: var(--color-bg-secondary, rgba(128, 128, 128, 0.12));
+}
+
 /* Raw-HTML block source text; inline raw HTML keeps --md-raw-html-color above. */
 :where(.editor) .text-editable-block.raw-block {
 	color: var(--syntax-comment, currentColor);
@@ -404,7 +442,7 @@
 }
 
 :where(.editor) .thematic-break-rule[role='separator'] > hr {
-	border-top-color: var(--syntax-separator, var(--color-ui-muted, #a4a4a4));
+	border-top-color: var(--syntax-separator, var(--color-border, #3e3e3b));
 }
 
 /* The [contenteditable='false'] qualifier scopes to the structurally-injected ambient
@@ -417,12 +455,69 @@
 	color: var(--syntax-task, currentColor);
 }
 
-/* Table grips reveal on table hover, in pure CSS with no per-grip reactive state. The grip's
-   own <style> holds the at-rest state, so it never intercepts a caret click until then. */
-:where(.editor) [role='table']:hover [data-table-col-grip],
-:where(.editor) [role='table']:hover [data-table-row-grip] {
-	opacity: 1;
-	pointer-events: auto;
+/* ── Menus ──────────────────────────────────────────────────────────────────
+   One surface for every menu the editor opens (the table's context menu, the code rail's
+   picker and overflow), copied from the host app's context menu value for value and reading
+   the same tokens, so a menu here is indistinguishable from one of the host's. */
+:where(.editor) .md-menu {
+	position: fixed;
+	z-index: 2000;
+	min-width: 168px;
+	padding: 4px;
+	background: var(--color-bg, #2c2c2a);
+	border: 1px solid var(--color-border, #3e3e3b);
+	border-radius: 8px;
+	box-shadow: var(--menu-shadow, 0 12px 32px rgba(0, 0, 0, 0.5), 0 2px 8px rgba(0, 0, 0, 0.35));
+	font-family: var(--font-ui, system-ui, sans-serif);
+	font-size: 13px;
+	line-height: 1.4;
+	color: var(--color-text-primary, #e8e8e5);
+	user-select: none;
+}
+
+:where(.editor) .md-menu-item {
+	display: flex;
+	align-items: center;
+	gap: 9px;
+	width: 100%;
+	padding: 7px 10px;
+	border: none;
+	border-radius: 5px;
+	background: transparent;
+	color: inherit;
+	font: inherit;
+	text-align: left;
+	cursor: pointer;
+}
+
+:where(.editor) .md-menu-item:hover,
+:where(.editor) .md-menu-item:focus-visible,
+:where(.editor) .md-menu-item[aria-pressed='true'],
+:where(.editor) .md-menu-item[data-active='true'] {
+	background: var(--menu-item-hover, rgba(255, 255, 255, 0.07));
+	outline: none;
+}
+
+:where(.editor) .md-menu-item:disabled {
+	opacity: 0.4;
+	cursor: default;
+}
+
+:where(.editor) .md-menu-item:disabled:hover {
+	background: transparent;
+}
+
+:where(.editor) .md-menu-icon {
+	display: inline-flex;
+	align-items: center;
+	flex-shrink: 0;
+	color: var(--color-ui-muted, #8f8f89);
+}
+
+:where(.editor) .md-menu-divider {
+	height: 1px;
+	margin: 4px 6px;
+	background: var(--color-border, #3e3e3b);
 }
 
 /* ── Rendered chrome, shared by every marker-hiding mode ──────────────────────
@@ -450,17 +545,33 @@
 }
 
 /* Chrome with nothing behind it has nowhere to hide: a construct whose only bytes are its own
-   markers would paint as an empty line with no caret position, so an editable rung shows them
-   dimmed exactly as source does. Mirrored in `cursor/widget-offset.ts` (same two modes, same
-   two families); reading takes no keystrokes and keeps its silence. The `[contenteditable]`
-   qualifier scopes the stamp to the walk containers its JS twin reads, which is what a block
-   decoration spelling `data-content-empty` onto the block host cannot reach. */
+   markers has no caret position, so an editable rung shows them dimmed as source does — but
+   only while the surface holds focus, since the seat is for a caret and a block nobody is in
+   reads as the empty construct it is. Mirrored in `cursor/widget-offset.ts` (same modes, same
+   families); reading keeps its silence. `[contenteditable]` scopes the stamp to the walk
+   containers its JS twin reads, which a decoration on the block host cannot reach. */
 :where(.editor):is([data-presentation^='preview-'], [data-presentation='live'])
-	[contenteditable][data-content-empty]
+	[contenteditable][data-content-empty]:focus-within
 	:is(.md-marker:not([contenteditable='false']), .md-fence-line) {
 	display: inline;
 }
 
+/* A code block or table is a box, and prose gives it nothing to stand off from: blocks stack flush,
+   with only a text line's own leading between them. The box brings its own breathing room —
+   about a text line's leading each side, so code-to-code and code-to-prose match. Padding,
+   not margin: the height model measures the host's border box. */
+:where(.editor) .block-host:is([data-block-kind='fencedCode'], [data-block-kind='table']) {
+	padding-block: 6px;
+}
+
+/* Room for the add strips (`TableBlock.svelte`) INSIDE the host's box: on the right so a
+   full-width table still leaves the column strip inside the editor's scroll box, and below so
+   the row strip never lies over whatever follows the table (the trailing insert row, a block). */
+:where(.editor) .block-host[data-block-kind='table'] {
+	padding-right: 30px;
+	padding-bottom: 24px;
+}
+
 /* Ambient list markers own the hanging indent (padding/text-indent are keyed to the span's
    ch width), so they keep their box: visibility, not display. */
 :where(.editor):is(
@@ -498,7 +609,21 @@
 	visibility: visible;
 }
 
-/* GitHub task lists carry no bullet, so the `- ` prefix hides and the checkbox stays. */
+/* GitHub task lists: no bullet, the box at the margin, the text one gap after it. The `- `
+   marker collapses to nothing (its bytes stay for the walk), the `[ ]` span becomes a fixed
+   slot so checked and unchecked are the same width, and the box paints in that slot. */
+:where(.editor):is(
+		[data-presentation='reading'],
+		[data-presentation^='preview-'],
+		[data-presentation='live']
+	)
+	.list-item-block[data-list-marker='task']
+	.task-list-marker {
+	display: inline-block;
+	width: 0;
+	overflow: hidden;
+}
+
 :where(.editor):is(
 		[data-presentation='reading'],
 		[data-presentation^='preview-'],
@@ -506,7 +631,72 @@
 	)
 	.list-item-block[data-list-marker='task']
 	.task-checkbox {
+	/* Visible inside the hidden ambient marker, its `[ ]` bytes gone by colour: a hidden span
+	   leaves the accessibility tree and the hit-test, and the pseudo-elements draw the box. */
 	visibility: visible;
+	color: transparent;
+	position: relative;
+	display: inline-block;
+	/* Slot + gap; `TASK_HANGING_INDENT` in task-checkbox.ts is these plus the trailing space. */
+	width: 1.2em;
+	margin-right: 0.65em;
+	vertical-align: baseline;
+}
+
+:where(.editor):is(
+		[data-presentation='reading'],
+		[data-presentation^='preview-'],
+		[data-presentation='live']
+	)
+	.list-item-block[data-list-marker='task']
+	.task-checkbox::before {
+	content: '';
+	visibility: visible;
+	position: absolute;
+	left: 50%;
+	top: 50%;
+	width: 1.2em;
+	height: 1.2em;
+	transform: translate(-50%, -50%);
+	box-sizing: border-box;
+	border: 1.5px solid var(--color-ui-muted, #8f8f89);
+	border-radius: 0.28em;
+	background: transparent;
+}
+
+/* Checked: the box fills with the text colour and the tick is cut from it in the page's
+   background — two borders of a rotated box, so it needs no glyph and scales with the type. */
+:where(.editor):is(
+		[data-presentation='reading'],
+		[data-presentation^='preview-'],
+		[data-presentation='live']
+	)
+	.list-item-block[data-task-checked='true']
+	.task-checkbox::before {
+	background: var(--color-text-primary, currentColor);
+	border-color: var(--color-text-primary, currentColor);
+}
+
+:where(.editor):is(
+		[data-presentation='reading'],
+		[data-presentation^='preview-'],
+		[data-presentation='live']
+	)
+	.list-item-block[data-task-checked='true']
+	.task-checkbox::after {
+	content: '';
+	visibility: visible;
+	position: absolute;
+	/* The slot's centre, nudged up and right: the visible strokes are the L's right and
+	   bottom edges, which rotation swings down and left. */
+	left: 53%;
+	top: 45%;
+	width: 0.32em;
+	height: 0.6em;
+	box-sizing: border-box;
+	border: solid var(--color-bg, #2c2c2a);
+	border-width: 0 0.15em 0.15em 0;
+	transform: translate(-50%, -50%) rotate(45deg);
 }
 
 /* ── Reading mode ─────────────────────────────────────────────────────────────
@@ -550,6 +740,15 @@
 	display: inline;
 }
 
+/* The body's caret anchor stands in for the closer line while that line hides (see
+   `code-renderer.ts`); wherever the closer paints it would add a blank line instead. */
+:where(.editor):not([data-presentation]) br[data-caret-anchor='closer'],
+:where(.editor)[data-presentation^='preview-']
+	.block-host[data-focused]
+	br[data-caret-anchor='closer'] {
+	display: none;
+}
+
 /* Reference labels reveal on the focused block under preview-block. */
 :where(.editor)[data-presentation='preview-block'] .block-host[data-focused] .md-ref-label {
 	display: inline;

package/dist/testing/container-conformance.js

@@ -19,7 +19,7 @@ import { isBlockOpenerRegistered } from '../schema/block-openers';
 import { getBlockKindDescriptor } from '../schema/block-kind-descriptor';
 import { rebuildContainerRawIfContainer } from '../schema/container-raw';
 import { createSharingState } from '../tree-operations/sharing';
-import { rebuildUnsharedAncestry } from '../tree-operations/unshare';
+import { rebuildUnsharedAncestry } from '../tree-operations/chain-rebuild';
 import { assertParseConverged } from './parse-convergence';
 import { createHeadlessActions, mountBlockListState, recordingFocus, stubBlockEdit, stubStickyColumn } from './headless-actions';
 import { assert, assertExemptionDocumented, assertIndices, assertIs, assertRebuildIsParseCanonical, assertReasonDocumented, fail, findFirstOfKind, firstChildOfKind, nodeAtPath, pathPassesThroughKind } from './conformance-core';
@@ -487,7 +487,7 @@ function assertContentStartSpaceIsRebuilt(kind, descriptor) {
 /**
  * `container.bodyWrap` is probed, never trusted: the separator settle reads it to decide whether
  * a freed blank line belongs to the wrap, and a kind whose parse disagrees loses its body head
- * on reload (`tree-operations/node-ops.clearRedundantSeparator`).
+ * on reload (`tree-operations/settle.clearRedundantSeparator`).
  */
 function assertBodyWrapMatchesParse(kind, descriptor) {
     if (descriptor.containerContract === 'grid')

package/dist/testing/inline-conformance.js

@@ -379,7 +379,8 @@ function assertRewriteReproducesSource(fixture, node, rung) {
         ...(node.title !== undefined ? { title: node.title } : {}),
         ...(node.label !== undefined ? { label: node.label } : {}),
         ...(node.width !== undefined ? { width: node.width } : {}),
-        ...(node.height !== undefined ? { height: node.height } : {})
+        ...(node.height !== undefined ? { height: node.height } : {}),
+        ...(node.crop !== undefined ? { crop: node.crop } : {})
     };
     assertIs(rung.rewriteImage(source, fields), source, `rewriteImage re-emits ${JSON.stringify(source)} from the fields the scan read out of it`);
 }

package/dist/tree-operations/blockquote.js

@@ -2,7 +2,7 @@ import { cloneMetadata, cloneNode } from './clone';
 import { rebuildBlockquoteRaw } from '../schema/container-rebuilders';
 import { rebuildContainerRaw } from '../schema/container-raw';
 import { assignIds } from '../block-id';
-import { emptyParagraph } from './node-ops';
+import { emptyParagraph } from './node-primitives';
 import { trailingLineEnding } from '../core/lines';
 /**
  * Unwrap a quote-shaped container's first child (Rule U2), returning fresh clones without

package/dist/tree-operations/chain-rebuild.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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 type { CstNode } from '../core/nodes';
+import type { SharingState } from './sharing';
+import type { NodeParent } from './node-primitives';
+import type { StructuralChange } from './structural-change';
+import type { GrammarView } from '../schema/block-openers';
+import { type TrackedPosition } from './settle';
+/**
+ * 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 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.
+ */
+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. `before` is the pre-splice array, the rollback
+ * register, since the splice lands in an array no commit descriptor covers.
+ */
+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. `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[];

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;
+};