@voithos-labs/aragonite 0.10.2 → 0.10.4

package/dist/cursor/scroll-hold.js

@@ -0,0 +1,22 @@
+/**
+ * Scroll-position hold across a block's render swap. A swap that shortens a block clamps the
+ * scrollport against the transient layout on the way to its settled height, and the clamp is
+ * never given back. A reveal in flight outranks the hold and owns the position; host mode does
+ * not, since native anchoring cannot undo a max-scroll clamp. Only a measure-then-fit surface
+ * needs this, and today that is one: an editable leaf's source is content-sized at mount.
+ */
+import { tick } from 'svelte';
+import { userScrollportFor } from './scroll-ancestors';
+import { createScrollport } from './scrollport';
+/** Capture the position of whatever scrolls `el`; await the result AFTER the state flip that
+ *  changes the block's height. */
+export function captureScrollPosition(el, isRevealInFlight) {
+    const port = el ? createScrollport(userScrollportFor(el)) : null;
+    const before = port?.scrollTop() ?? 0;
+    return async () => {
+        await tick();
+        if (!port || isRevealInFlight() || port.scrollTop() === before)
+            return;
+        port.setScrollTop(before);
+    };
+}

package/dist/cursor/scrollport.d.ts

@@ -14,7 +14,16 @@ export interface Scrollport {
     contentWidth(): number;
     scrollTop(): number;
     setScrollTop(value: number): void;
+    /** Move by `delta`. The only relative write: see {@link withRelativeScroll}. */
+    scrollBy(delta: number): void;
     /** Fires on user and programmatic scrolls alike; returns the unsubscribe. */
     subscribe(onScroll: () => void): () => void;
 }
 export declare function createScrollport(target: UserScrollport): Scrollport;
+/**
+ * Adds the relative write every corrector goes through. A scroller snaps a fractional write to
+ * a whole device pixel and reports the snapped value back, so a run of relative corrections (a
+ * mode flip fires one per re-measured block) would drop that fraction every time and slide the
+ * reader's content by the sum. The refused fraction carries into the next call instead.
+ */
+export declare function withRelativeScroll(base: Omit<Scrollport, 'scrollBy'>): Scrollport;

package/dist/cursor/scrollport.js

@@ -1,5 +1,34 @@
 export function createScrollport(target) {
-    return target === window ? pageScrollport() : elementScrollport(target);
+    return withRelativeScroll(target === window ? pageScrollport() : elementScrollport(target));
+}
+/**
+ * Adds the relative write every corrector goes through. A scroller snaps a fractional write to
+ * a whole device pixel and reports the snapped value back, so a run of relative corrections (a
+ * mode flip fires one per re-measured block) would drop that fraction every time and slide the
+ * reader's content by the sum. The refused fraction carries into the next call instead.
+ */
+export function withRelativeScroll(base) {
+    let carried = 0;
+    let written = null;
+    return {
+        ...base,
+        setScrollTop(value) {
+            base.setScrollTop(value);
+            carried = 0;
+            written = null;
+        },
+        scrollBy(delta) {
+            const from = base.scrollTop();
+            // Anything that moved the port since our own write (the reader, a reveal) leaves the
+            // carried fraction describing a position nobody holds any more.
+            const target = from + (written === from ? carried : 0) + delta;
+            base.setScrollTop(target);
+            written = base.scrollTop();
+            const refused = target - written;
+            // Only the snap's own fraction carries; a clamp at either end is a real refusal.
+            carried = Math.abs(refused) < 1 ? refused : 0;
+        }
+    };
 }
 // ── Internal ───────────────────────────────────────────────────────────────
 function elementScrollport(el) {

package/dist/cursor/visual-lines.d.ts

@@ -1,8 +1,9 @@
 /**
- * Whether the cursor sits on the first or last visual line of a wrapping element. Offsets
- * alone can't answer it past 2 wrapped lines, so cursor Y is compared to the first/last
- * line's Y. The text-node walk works around collapsed ranges next to non-text children
- * (dimmed marker spans) returning null rects — measuring around real text always works.
+ * Whether the cursor sits on the first or last visual line of a wrapping element. Offsets alone
+ * can't answer it past 2 wrapped lines, so the cursor's line is compared to the edge line's.
+ * Collapsed ranges beside non-text children (dimmed markers, atomic islands) measure to nothing,
+ * so the edge line is measured around real text, and a rect-less caret reads the box it sits
+ * against.
  */
 /** The first rect that can position a caret: the leading client rect when it has real
  *  height, else the bounding rect. `widthTolerant` also accepts a zero-height rect with width. */

package/dist/cursor/visual-lines.js

@@ -1,8 +1,9 @@
 /**
- * Whether the cursor sits on the first or last visual line of a wrapping element. Offsets
- * alone can't answer it past 2 wrapped lines, so cursor Y is compared to the first/last
- * line's Y. The text-node walk works around collapsed ranges next to non-text children
- * (dimmed marker spans) returning null rects — measuring around real text always works.
+ * Whether the cursor sits on the first or last visual line of a wrapping element. Offsets alone
+ * can't answer it past 2 wrapped lines, so the cursor's line is compared to the edge line's.
+ * Collapsed ranges beside non-text children (dimmed markers, atomic islands) measure to nothing,
+ * so the edge line is measured around real text, and a rect-less caret reads the box it sits
+ * against.
  */
 import { domDescendants } from './dom-walk';
 import { FALLBACK_LINE_HEIGHT } from './typography-estimates';
@@ -61,6 +62,7 @@ export function findLastTextNode(root) {
 export function isAtFirstVisualLine(el, fallbackOffset, contentStart) {
     return isAtEdgeVisualLine(el, () => fallbackOffset <= contentStart, {
         isEmpty: (el.textContent ?? '').length === 0,
+        toStart: true,
         boundaryTop: () => {
             const firstText = findFirstTextNode(el);
             const top = firstText ? getCharRangeTop(firstText, 0, false) : null;
@@ -71,6 +73,7 @@ export function isAtFirstVisualLine(el, fallbackOffset, contentStart) {
 export function isAtLastVisualLine(el, fallbackOffset, contentEnd) {
     return isAtEdgeVisualLine(el, () => fallbackOffset >= contentEnd, {
         isEmpty: contentEnd === 0,
+        toStart: false,
         boundaryTop: () => {
             const lastText = findLastTextNode(el);
             const top = lastText ? getCharRangeTop(lastText, lastText.textContent.length, true) : null;
@@ -80,7 +83,7 @@ export function isAtLastVisualLine(el, fallbackOffset, contentEnd) {
 }
 // ── Internal ────────────────────────────────────────────────────────────────
 /** The shared skeleton of the two edge predicates: `fallback` answers where geometry cannot — a
- *  dropped range, an unmeasurable collapsed caret, an unmeasurable boundary line — and
+ *  dropped range, a caret no box can be found for, an unmeasurable boundary line — and
  *  `boundaryTop` measures the edge line each side's own way. */
 function isAtEdgeVisualLine(el, fallback, edge) {
     const sel = window.getSelection();
@@ -89,19 +92,61 @@ function isAtEdgeVisualLine(el, fallback, edge) {
     if (edge.isEmpty)
         return true;
     const cursorRange = sel.getRangeAt(0);
+    const lineHeight = parseFloat(getComputedStyle(el).lineHeight) || FALLBACK_LINE_HEIGHT;
+    const tolerance = lineHeight * SAME_LINE_TOLERANCE;
     const cursorTop = getRangeTop(cursorRange);
-    if (cursorTop === null)
-        return cursorRange.collapsed ? fallback() : true;
+    if (cursorTop === null) {
+        if (!cursorRange.collapsed)
+            return true;
+        // A caret beside an atomic island sits at an element-level position and measures to no rect
+        // of its own: it rides the island's box, and is at the edge line when nothing reaches past.
+        const band = neighbourBand(cursorRange);
+        const contents = bandOfRange(contentsRange(el));
+        if (!band || !contents)
+            return fallback();
+        return edge.toStart
+            ? band.top < contents.top + tolerance
+            : band.bottom > contents.bottom - tolerance;
+    }
     const edgeTop = edge.boundaryTop();
     if (edgeTop === null)
         return fallback();
-    const lineHeight = parseFloat(getComputedStyle(el).lineHeight) || FALLBACK_LINE_HEIGHT;
-    return Math.abs(cursorTop - edgeTop) < lineHeight * SAME_LINE_TOLERANCE;
+    return Math.abs(cursorTop - edgeTop) < tolerance;
 }
-/** The boundary line's collapsed-contents fallback measurement. */
-function collapsedContentsTop(el, toStart) {
+/** The vertical band of the box a rect-less caret sits against: the child it precedes, else the
+ *  one it follows. Null where the caret is not at an element-level position. */
+function neighbourBand(range) {
+    const container = range.startContainer;
+    if (container.nodeType !== Node.ELEMENT_NODE)
+        return null;
+    const children = container.childNodes;
+    return (nodeBand(children[range.startOffset], false) ?? nodeBand(children[range.startOffset - 1], true));
+}
+function nodeBand(node, fromEnd) {
+    if (!node)
+        return null;
+    const range = document.createRange();
+    range.selectNode(node);
+    // A node that wraps has one rect per line, and the caret touches the line on its own side.
+    const rects = range.getClientRects();
+    if (rects.length === 0)
+        return bandOfRange(range);
+    return bandOf(rects[fromEnd ? rects.length - 1 : 0]);
+}
+function contentsRange(el) {
     const range = document.createRange();
     range.selectNodeContents(el);
+    return range;
+}
+function bandOfRange(range) {
+    return bandOf(range.getBoundingClientRect());
+}
+function bandOf(rect) {
+    return rect.height > 0 ? { top: rect.top, bottom: rect.bottom } : null;
+}
+/** The boundary line's collapsed-contents fallback measurement. */
+function collapsedContentsTop(el, toStart) {
+    const range = contentsRange(el);
     range.collapse(toStart);
     return getRangeTop(range);
 }

package/dist/cursor/widget-edge-snap.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Which atomic island's raw edge a point lands on: the NEAREST edge among the islands the caller
+ * measures, so a run of flush islands answers the one the point is actually beside. A point inside
+ * one reads its kind: a character-like island names the edge on the point's side, while an island
+ * that selects whole declines and keeps its own click handling.
+ */
+export interface WidgetEdgeCandidate {
+    /** The island's own raw source span; the caret seats at one end or the other. */
+    start: number;
+    end: number;
+    rect: Pick<DOMRect, 'left' | 'right' | 'top' | 'bottom'>;
+    /** The kind reads as one character, so a press ON it names an edge by side rather than
+     *  selecting the island whole. */
+    seatsInside: boolean;
+}
+export interface WidgetEdgeSeat {
+    offset: number;
+    /** The press landed ON the island: the engine answers such a point with a position in the
+     *  neighbouring text, so its own caret is no reason to stand this seat down. */
+    inside: boolean;
+}
+/**
+ * The raw offset a point snaps to, in document order for ties. Null where the point snaps to none:
+ * inside an island that selects whole, whose own click handling owns it, or with no island to
+ * either side. A null `y` is a point with no line to compare against, so vertical distance drops
+ * out and horizontal containment alone reads as inside.
+ */
+export declare function nearestWidgetEdgeSeat(candidates: Iterable<WidgetEdgeCandidate>, x: number, y: number | null): WidgetEdgeSeat | null;

package/dist/cursor/widget-edge-snap.js

@@ -0,0 +1,38 @@
+/**
+ * Which atomic island's raw edge a point lands on: the NEAREST edge among the islands the caller
+ * measures, so a run of flush islands answers the one the point is actually beside. A point inside
+ * one reads its kind: a character-like island names the edge on the point's side, while an island
+ * that selects whole declines and keeps its own click handling.
+ */
+/**
+ * The raw offset a point snaps to, in document order for ties. Null where the point snaps to none:
+ * inside an island that selects whole, whose own click handling owns it, or with no island to
+ * either side. A null `y` is a point with no line to compare against, so vertical distance drops
+ * out and horizontal containment alone reads as inside.
+ */
+export function nearestWidgetEdgeSeat(candidates, x, y) {
+    let best = null;
+    for (const { start, end, rect, seatsInside } of candidates) {
+        const withinRow = y === null || (rect.top < y && y < rect.bottom);
+        if (rect.left < x && x < rect.right && withinRow) {
+            if (!seatsInside)
+                return null;
+            return { offset: x < (rect.left + rect.right) / 2 ? start : end, inside: true };
+        }
+        // Rows before columns: a point past the end of one line must not reach an island on
+        // another line that happens to sit at the same x.
+        const rowGap = y === null ? 0 : Math.max(rect.top - y, y - rect.bottom, 0);
+        if (x <= rect.left)
+            best = nearer(best, { offset: start, rowGap, gap: rect.left - x });
+        if (x >= rect.right)
+            best = nearer(best, { offset: end, rowGap, gap: x - rect.right });
+    }
+    return best === null ? null : { offset: best.offset, inside: false };
+}
+function nearer(held, next) {
+    if (!held)
+        return next;
+    if (next.rowGap !== held.rowGap)
+        return next.rowGap < held.rowGap ? next : held;
+    return next.gap < held.gap ? next : held;
+}

package/dist/cursor/widget-offset.d.ts

@@ -42,6 +42,9 @@ export declare function findDomTextOffsetTarget(container: ParentNode, target: D
  * against the ambient-adjusted argument.
  */
 export declare function widgetsIntersectingRange(container: HTMLElement, start: DomTextOffset, end: DomTextOffset): HTMLElement[];
+/** The walk's text with marker chrome and widget bytes blanked to spaces, at the walk's own
+ *  offsets: what a rule reading words (the multi-click ladder) sees as content. */
+export declare function maskedWalkText(container: ParentNode): string;
 /** Total walk length of `container` — its one-past-end walk position. */
 export declare function containerDomTextLength(container: ParentNode): DomTextOffset;
 /**
@@ -101,6 +104,12 @@ export declare function landableDomTextBounds(container: ParentNode): {
  * questions: a reference label is chrome that stays hidden, so it is not content standing behind
  * the stamp, and it is not the paint the stamp promises either.
  */
+/**
+ * The container's bytes outside its marker chrome — what a painted source holds as CONTENT,
+ * whatever the mode paints. A fence with an empty body answers whitespace; the leaf reads that
+ * as "nothing here a Backspace could mean but the block".
+ */
+export declare function chromeFreeText(container: ParentNode): string;
 export declare function holdsOnlyMarkerChrome(container: ParentNode): boolean;
 /**
  * Whether the mode paints NOTHING landable here: every walk segment is a hidden marker run, so no

package/dist/cursor/widget-offset.js

@@ -85,8 +85,11 @@ export function findDomTextOffsetTarget(container, target) {
         const after = positionBeside(seg.last, 'after');
         if (!after)
             continue;
-        if (seg.start + seg.len >= target)
+        // Chromium canonicalizes the slot after a HIDDEN run upstream across it, so a byte typed
+        // there lands before the run; text starting at the target is the position that keeps it.
+        if (seg.start + seg.len > target || (seg.start + seg.len === target && !seg.hidden)) {
             return after;
+        }
         last = after;
     }
     return last;
@@ -108,6 +111,16 @@ export function widgetsIntersectingRange(container, start, end) {
     }
     return out;
 }
+/** The walk's text with marker chrome and widget bytes blanked to spaces, at the walk's own
+ *  offsets: what a rule reading words (the multi-click ladder) sees as content. */
+export function maskedWalkText(container) {
+    let out = '';
+    for (const seg of walkSegments(container, null)) {
+        const content = seg.kind === 'text' && markerRootOf(seg.node, container) === null;
+        out += content ? (seg.node.textContent ?? '') : ' '.repeat(seg.len);
+    }
+    return out;
+}
 /** Total walk length of `container` — its one-past-end walk position. */
 export function containerDomTextLength(container) {
     let count = 0;
@@ -239,7 +252,19 @@ export function revealsNoMarkers(container) {
  * An unmounted surface reads as source, where nothing hides and no rewrite has a run to move.
  */
 export function screenVisibilityOf(container) {
-    return screenVisibility(container === null ? 'source' : (markerHidingMode(container) ?? 'source'), { chromePaints: container instanceof Element && container.hasAttribute(CONTENT_EMPTY_ATTR) });
+    return screenVisibility(container === null ? 'source' : (markerHidingMode(container) ?? 'source'), { chromePaints: container instanceof Element && chromeStampPaints(container) });
+}
+/**
+ * The stamp's own condition, as `styles/editor.css` states it: the container carries
+ * `data-content-empty` AND holds focus. The seat is for a caret, so a stamped block nobody is in
+ * keeps its chrome hidden and reads as the empty construct it is. Focus containment rather than
+ * `:focus-within`, so a selector engine without that pseudo-class (jsdom's) reads the same answer.
+ */
+function chromeStampPaints(container) {
+    if (!container.hasAttribute(CONTENT_EMPTY_ATTR))
+        return false;
+    const active = container.ownerDocument.activeElement;
+    return active !== null && container.contains(active);
 }
 /**
  * The extreme walk offsets a caret can occupy in `container`: a hidden marker run or the leading
@@ -252,6 +277,7 @@ export function landableDomTextBounds(container) {
     let start = 0;
     let end = 0;
     let landed = false;
+    let lastText = null;
     for (const seg of landingSegments(container, markerHidingMode(container))) {
         if (seg.len === 0)
             continue;
@@ -265,9 +291,28 @@ export function landableDomTextBounds(container) {
         }
         landed = true;
         end = stop;
+        lastText = seg.kind === 'text' ? seg.node : null;
+    }
+    // The position after the last landable run's final `\n` is the start of a line nothing
+    // paints: the engine seats no caret there, so an end gate reading it never fires and the
+    // caret is stuck on the empty line. A caret anchor gives that line its paint and keeps it.
+    if (lastText?.textContent?.endsWith('\n') && !followedByCaretAnchor(lastText, container)) {
+        end -= 1;
     }
     return { start: asDomTextOffset(start), end: asDomTextOffset(Math.max(start, end)) };
 }
+/** Whether the next painted node after `text`, at any depth above it, is a caret anchor. */
+function followedByCaretAnchor(text, root) {
+    for (let node = text; node && node !== root; node = node.parentNode) {
+        let next = node.nextSibling;
+        while (next?.nodeType === Node.TEXT_NODE && (next.textContent?.length ?? 0) === 0) {
+            next = next.nextSibling;
+        }
+        if (next)
+            return next instanceof HTMLElement && next.tagName === 'BR' && 'caretAnchor' in next.dataset;
+    }
+    return false;
+}
 /**
  * Whether every byte `container` holds is marker chrome, at least one span of it a family the
  * empty-construct override paints. The stamp condition the render path writes as
@@ -276,6 +321,22 @@ export function landableDomTextBounds(container) {
  * questions: a reference label is chrome that stays hidden, so it is not content standing behind
  * the stamp, and it is not the paint the stamp promises either.
  */
+/**
+ * The container's bytes outside its marker chrome — what a painted source holds as CONTENT,
+ * whatever the mode paints. A fence with an empty body answers whitespace; the leaf reads that
+ * as "nothing here a Backspace could mean but the block".
+ */
+export function chromeFreeText(container) {
+    let text = '';
+    for (const seg of walkSegments(container, null)) {
+        if (seg.kind !== 'text' || seg.len === 0)
+            continue;
+        if (markerRootOf(seg.node, container) !== null)
+            continue;
+        text += seg.node.textContent ?? '';
+    }
+    return text;
+}
 export function holdsOnlyMarkerChrome(container) {
     let chrome = false;
     for (const seg of walkSegments(container, null)) {
@@ -383,8 +444,7 @@ function markerRootOf(node, root) {
 function chromeStandsAloneUnder(root, mode) {
     if (mode === null || !(root instanceof Element))
         return false;
-    return screenVisibility(mode, { chromePaints: root.hasAttribute(CONTENT_EMPTY_ATTR) })
-        .chromePaints;
+    return screenVisibility(mode, { chromePaints: chromeStampPaints(root) }).chromePaints;
 }
 /**
  * Whether `node` is inside the leading ambient marker island — a container's `- ` / `1. ` prefix,
@@ -442,8 +502,15 @@ function positionBeside(el, side) {
         return { node: sibling, offset: side === 'before' ? (sibling.textContent?.length ?? 0) : 0 };
     }
     const idx = Array.prototype.indexOf.call(parent.childNodes, el);
+    // A pending hard break's first anchor (`inline-render.ts`) ends the line the marker sat on;
+    // the seat past the marker is the start of the next one, which is after that anchor.
+    if (side === 'after' && isBreakAnchor(sibling))
+        return { node: parent, offset: idx + 2 };
     return { node: parent, offset: side === 'before' ? idx : idx + 1 };
 }
+function isBreakAnchor(node) {
+    return (node instanceof HTMLElement && node.tagName === 'BR' && node.dataset.caretAnchor === 'break');
+}
 /**
  * The classification every walk-space consumer shares: a text node contributes its textContent
  * length, an atomic widget its raw source length (never descended), any other element is

package/dist/debug/interaction-trace.d.ts

@@ -17,6 +17,7 @@ export declare function disableInteractionTrace(): void;
 export declare function isInteractionTraceEnabled(): boolean;
 /** Empty the buffer without touching the enabled flag — test isolation. */
 export declare function resetInteractionTrace(): void;
+export declare function interactionTraceKeydownCount(): number;
 export declare function interactionTraceSnapshot(): InteractionTraceEntry[];
 /** `changed` names the differing render-key segments, comma-joined. */
 export declare function traceRebuild(changed: string, force: boolean): void;
@@ -37,3 +38,6 @@ export declare function traceCompositionEnd(): void;
 export declare function traceIslandsApplied(count: number): void;
 export declare function traceStickyCapture(x: number): void;
 export declare function traceStickyReset(): void;
+/** `handled` is the event's own `defaultPrevented`: whether the editor claimed the press.
+ *  Recorded once per keydown, after the surface handler's await chain has settled. */
+export declare function traceKeydownVerdict(key: string, handled: boolean): void;

package/dist/debug/interaction-trace.js

@@ -8,6 +8,9 @@
 const CAPACITY = 200;
 let enabled = false;
 let buf = [];
+// Monotonic, so the harness poll costs one read and the ring buffer's eviction cannot
+// retract a verdict it already counted.
+let keydownVerdicts = 0;
 // ── Switch and readout ──────────────────────────────────────────────────────
 export function enableInteractionTrace() {
     enabled = true;
@@ -21,6 +24,10 @@ export function isInteractionTraceEnabled() {
 /** Empty the buffer without touching the enabled flag — test isolation. */
 export function resetInteractionTrace() {
     buf = [];
+    keydownVerdicts = 0;
+}
+export function interactionTraceKeydownCount() {
+    return keydownVerdicts;
 }
 export function interactionTraceSnapshot() {
     return buf.slice();
@@ -103,3 +110,11 @@ export function traceStickyReset() {
         return;
     record('sticky-column', 'reset');
 }
+/** `handled` is the event's own `defaultPrevented`: whether the editor claimed the press.
+ *  Recorded once per keydown, after the surface handler's await chain has settled. */
+export function traceKeydownVerdict(key, handled) {
+    if (!enabled)
+        return;
+    keydownVerdicts++;
+    record('keydown', 'verdict', { key, handled });
+}

package/dist/decorations/decoration-state.svelte.js

@@ -5,7 +5,7 @@ import { islandPosition } from './island-dom';
 import { assertInvariant } from '../assert';
 import { isCommitInProgress } from '../invariants/commit-scope';
 import { contentLengthOf, isProseKind } from '../core/inline';
-import { isBlockNode, nodeAt } from '../tree-operations/node-ops';
+import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
 import { devWarn } from '../dev-warn';
 import { recordDecorationRun } from '../perf/instruments';
 const EMPTY_MARKS = [];

package/dist/decorations/reserved-attrs.js

@@ -18,6 +18,7 @@ export const RESERVED_BLOCK_ATTRS = new Set([
     'data-image-widget',
     'data-inline-widget',
     'data-link-card',
+    'data-pointer-gesture',
     'data-presentation',
     'data-table-row-idx'
 ]);

package/dist/editor-actions/ancestry-folds.d.ts

@@ -1,10 +1,10 @@
 /**
- * Publishing side of the ancestry settle (`tree-operations/unshare.ts`): a fold at a container's
+ * Publishing side of the ancestry settle (`tree-operations/chain-rebuild.ts`): a fold at a container's
  * own slot splices its PARENT's children, a scope the commit's own change descriptor never
  * covers, so that scope's ids and refs are resynced here instead.
  */
 import type { CstNode } from '../core/nodes';
-import type { AncestrySeamFold } from '../tree-operations/unshare';
+import type { AncestrySeamFold } from '../tree-operations/chain-rebuild';
 import { type StructuralChange } from '../tree-operations/structural-change';
 import type { EditorActionsDeps } from './deps';
 /** Where the folded container's first byte ended up, as a document path. */

package/dist/editor-actions/ancestry-folds.js

@@ -1,5 +1,5 @@
 /**
- * Publishing side of the ancestry settle (`tree-operations/unshare.ts`): a fold at a container's
+ * Publishing side of the ancestry settle (`tree-operations/chain-rebuild.ts`): a fold at a container's
  * own slot splices its PARENT's children, a scope the commit's own change descriptor never
  * covers, so that scope's ids and refs are resynced here instead.
  */

package/dist/editor-actions/block-edit-scope.js

@@ -44,7 +44,7 @@ export function createTopLevelScope(deps, controller) {
 // ── Container adapter ────────────────────────────────────────────────────────
 export function createContainerScope(state, deps) {
     return {
-        // A fold at this container's own slot detaches it (`tree-operations/unshare.ts`), so a
+        // A fold at this container's own slot detaches it (`tree-operations/chain-rebuild.ts`), so a
         // post-commit read can find the scope gone rather than merely empty.
         children: () => deps.node?.children ?? [],
         refAt: (i) => state.innerBlockRefs[i],

package/dist/editor-actions/commit/text-batch.d.ts

@@ -6,8 +6,9 @@
 export interface TextBatchDeps {
     /** Capture the pre-edit snapshot for the first keystroke of a batch. */
     pushSnapshot(leafPath: number[], offset: number): void;
-    /** Emit the batched `input` edit event when a batch flushes. */
-    emitInput(leafPath: number[], byteLength: number): void;
+    /** Emit the batched `input` edit event when a batch flushes. Omitted by a batch with no edit
+     *  channel of its own: a revealed source's bytes reach it once, on the fold's commit. */
+    emitInput?(leafPath: number[], byteLength: number): void;
 }
 export interface TextBatch {
     /**

package/dist/editor-actions/commit/text-batch.js

@@ -17,7 +17,7 @@ export function createTextBatch(deps) {
      */
     function flushPendingInput() {
         if (batchByteLength > 0 && batchPath) {
-            deps.emitInput(batchPath, batchByteLength);
+            deps.emitInput?.(batchPath, batchByteLength);
         }
         batchPath = null;
         batchByteLength = 0;

package/dist/editor-actions/commit/undo-controller.js

@@ -12,8 +12,10 @@ import { assertInvariant } from '../../assert';
 import { beginCommit, endCommit } from '../../invariants/commit-scope';
 import { assignIds } from '../../block-id';
 import { replaceRefs } from '../../reactivity/publish-ref.svelte';
-import { nodeAt, settleSeparator } from '../../tree-operations/node-ops';
-import { attachedChainPrefix, ensureUnsharedPath, rebuildUnsharedChain } from '../../tree-operations/unshare';
+import { nodeAt } from '../../tree-operations/node-primitives';
+import { settleSeparator } from '../../tree-operations/settle';
+import { ensureUnsharedPath } from '../../tree-operations/unshare';
+import { attachedChainPrefix, rebuildUnsharedChain } from '../../tree-operations/chain-rebuild';
 import { foldLandingFor, publishAncestryFolds } from '../ancestry-folds';
 import { createTextBatch } from './text-batch';
 import { toEditEvent } from '../../editor-events';

package/dist/editor-actions/container-edit.js

@@ -2,7 +2,8 @@
  * ContainerEditActions factory: the debounced checkpoint pusher for raw typing
  * outside the commit primitive, the doc-root reactivity nudge, and `commitContainer`.
  */
-import { ensureUnsharedPath, rebuildUnsharedChain } from '../tree-operations/unshare';
+import { ensureUnsharedPath } from '../tree-operations/unshare';
+import { rebuildUnsharedChain } from '../tree-operations/chain-rebuild';
 import { publishAncestryFolds, publishScopeFold } from './ancestry-folds';
 export function createContainerEditActions(deps, controller) {
     return {

package/dist/editor-actions/enter-completion.d.ts

@@ -23,3 +23,5 @@ export interface EnterCompletion {
 export declare function withEnterCompletion(blockEdit: BlockEditActions, childAt: (index: number) => NodeView | undefined): BlockEditActions;
 /** The completion a press at `offset` earns, or null when the block or the caret disqualifies it. */
 export declare function planEnterCompletion(node: NodeView | undefined, offset: number): EnterCompletion | null;
+/** The completion a keystroke earns, consulting only the completers that answer on type. */
+export declare function planTypedCompletion(node: NodeView | undefined, offset: number): EnterCompletion | null;

package/dist/editor-actions/enter-completion.js

@@ -6,7 +6,7 @@
 import { parse } from '../core/parser';
 import { displayLength, splitLines, trailingLineEnding } from '../core/lines';
 import { getBlockKindDescriptor } from '../schema/block-kind-descriptor';
-import { completeTypedLine } from '../schema/block-completions';
+import { completeLineOnType, completeTypedLine } from '../schema/block-completions';
 /**
  * Wraps a COMPOSED `splitBlock` with the consult, at the two bundle composition sites only. Above
  * the container overrides rather than inside the split body, so a container that replaces
@@ -26,17 +26,38 @@ export function withEnterCompletion(blockEdit, childAt) {
             // `snapshotOffset` is where the caret WAS, so one undo restores the typed line with the
             // caret at its end rather than in front of it.
             await blockEdit.replaceBlock(index, completion.replacement, { replacementIndex: 0, ...completion.caret }, { snapshotOffset: offset });
+        },
+        // The typed arm: a keystroke that leaves the block as a line an on-type completer claims
+        // (see `BlockCompleter.onType`) forms the structure at once, the way a typed ` ``` ` is a
+        // fence the moment the parser sees it. The write lands first, so the typed line is its own
+        // undo step and the mint replaces the bytes the CST actually holds.
+        async updateBlockContent(index, text, preEditOffset, postEditFocusOffset) {
+            await blockEdit.updateBlockContent(index, text, preEditOffset, postEditFocusOffset);
+            const offset = postEditFocusOffset ?? preEditOffset;
+            if (offset === undefined)
+                return;
+            const completion = planTypedCompletion(childAt(index), offset);
+            if (!completion)
+                return;
+            await blockEdit.replaceBlock(index, completion.replacement, { replacementIndex: 0, ...completion.caret }, { snapshotOffset: offset });
         }
     };
 }
 /** The completion a press at `offset` earns, or null when the block or the caret disqualifies it. */
 export function planEnterCompletion(node, offset) {
+    return planCompletion(node, offset, completeTypedLine);
+}
+/** The completion a keystroke earns, consulting only the completers that answer on type. */
+export function planTypedCompletion(node, offset) {
+    return planCompletion(node, offset, completeLineOnType);
+}
+function planCompletion(node, offset, consult) {
     if (!node)
         return null;
     const line = wholeTypedLine(node);
     if (line === null || offset !== displayLength(node.raw))
         return null;
-    const claim = completeTypedLine(line);
+    const claim = consult(line);
     if (!claim)
         return null;
     // Through the parser rather than a hand-built node, so the mint is exactly what a reload of