@voithos-labs/aragonite 0.10.1

package/dist/components/blocks/text/TextEditableBlock.svelte.d.ts

@@ -0,0 +1,33 @@
+import { type AmbientPrefix } from '../../../block-component';
+import type { DocumentView, NodeView } from '../../../core/node-views';
+import type { EditorRects } from '../../../editor-rects';
+import { type CommandId } from '../../../schema/commands';
+type $$ComponentProps = {
+    node: NodeView;
+    index: number;
+    myPath?: number[];
+    blockClass?: string;
+    ambientPrefix?: AmbientPrefix;
+    document?: DocumentView;
+    rects?: EditorRects;
+};
+declare const TextEditableBlock: import("svelte").Component<$$ComponentProps, {
+    editable: true;
+    focusable: true;
+    focus: (offset: number) => void;
+    parkCaret: (offset: number) => void;
+    focusAtColumn: (x: number, from: import("../../../block-component").StickyColumnDirection) => void;
+    getCursorOffset: () => number | null;
+    getSelectedText: () => string;
+    setSelection: (start: number, end: number) => void;
+    measurePartialRects: (startOffset: number, endOffset: number) => DOMRect[];
+    isVerticallyTransparent: () => boolean;
+    enterEdgeWidget: (side: "start" | "end") => boolean;
+    claimRootClipboard: (event: ClipboardEvent) => void;
+    insertMarkdown: (md: string) => boolean;
+    snapCaretToPoint: (clientX: number, clientY: number) => void;
+    runCommand: (id: CommandId, arg?: unknown) => boolean;
+    isCommandActive: (id: CommandId) => boolean;
+}, "">;
+type TextEditableBlock = ReturnType<typeof TextEditableBlock>;
+export default TextEditableBlock;

package/dist/components/blocks/text/click-snap-guard.d.ts

@@ -0,0 +1,8 @@
+/** Native-vs-synthetic caret and plain-key guards shared across the text surface. */
+/** Caret in a real text node the reader can see: the native caret renders there, so the
+ *  synthetic indicator stands down. Hidden marker text renders nothing, so it does not count. */
+export declare function caretIsInTextContent(el: HTMLElement, sel: Selection | null): boolean;
+/** Ctrl/meta/alt held — a platform command, never an edit of the byte beside the caret. */
+export declare function hasModifier(e: KeyboardEvent): boolean;
+/** A typed character: no modifier chord, one code point. A chord is a command instead. */
+export declare function isPlainTypingKey(e: KeyboardEvent): boolean;

package/dist/components/blocks/text/click-snap-guard.js

@@ -0,0 +1,19 @@
+/** Native-vs-synthetic caret and plain-key guards shared across the text surface. */
+import { isCharacterKey } from '../../../schema/keybindings';
+import { isHiddenMarkerText } from '../../../cursor/widget-offset';
+/** Caret in a real text node the reader can see: the native caret renders there, so the
+ *  synthetic indicator stands down. Hidden marker text renders nothing, so it does not count. */
+export function caretIsInTextContent(el, sel) {
+    if (!sel || sel.rangeCount === 0)
+        return false;
+    const node = sel.getRangeAt(0).startContainer;
+    return node.nodeType === Node.TEXT_NODE && el.contains(node) && !isHiddenMarkerText(node, el);
+}
+/** Ctrl/meta/alt held — a platform command, never an edit of the byte beside the caret. */
+export function hasModifier(e) {
+    return e.ctrlKey || e.metaKey || e.altKey;
+}
+/** A typed character: no modifier chord, one code point. A chord is a command instead. */
+export function isPlainTypingKey(e) {
+    return !hasModifier(e) && isCharacterKey(e.key);
+}

package/dist/components/blocks/text/composition-seat.d.ts

@@ -0,0 +1,50 @@
+/**
+ * One composition's worth of seat inputs, captured at `compositionstart`. Both inputs the commit's
+ * relocation needs — the arrival side and the pending marks — belong to the caret the composition
+ * OPENED at, and the affinity re-arm has spent them by the time the composed run arrives.
+ */
+import type { InlineNode } from '../../../core/nodes';
+import type { VisibilityContext } from '../../../core/inline/visibility';
+import type { EdgeAffinity } from '../../../cursor/edge-affinity';
+import type { InlineMarkKind } from '../../../schema/inline-construct-policy';
+export interface CompositionSeatDeps {
+    /** The block's display bytes — what a commit's read is compared against. */
+    getDisplayText: () => string;
+    getInlines: () => readonly InlineNode[];
+    getAffinity: () => EdgeAffinity | null;
+    /** How the surface reads on screen, for the seat's own painted-range question. */
+    getScreen: () => VisibilityContext;
+    /** Spend the pending marks: a composition is the one insertion they were promised to. */
+    consumePendingMarks: () => ReadonlySet<InlineMarkKind> | null;
+    /** Give them back when the composition committed nothing — an IME cancel inserts no run, so
+     *  the promise is still owed. Required, so both surfaces answer for it alike. */
+    restorePendingMarks: (marks: ReadonlySet<InlineMarkKind>) => void;
+    /** The block's live selection, read at compositionstart: composing over one is a range op no
+     *  plain-insertion arm claims, so it routes to `resolveRangeEdit`. Omit to keep ranges verbatim. */
+    getRawSelection?: () => {
+        start: number;
+        end: number;
+    } | null;
+    /** The surface's join-seam resolution for a range replace, in display bytes; null keeps the
+     *  engine's own edit — the same decline contract as the keydown selection-edit arm. */
+    resolveRangeEdit?: (range: {
+        start: number;
+        end: number;
+    }, typed: string) => {
+        raw: string;
+        caret: number;
+    } | null;
+}
+export interface CompositionSeat {
+    /** Capture the window the composition opened in. Call BEFORE the surface's own
+     *  `compositionstart`, whose cross-block half clears the affinity, and before the first
+     *  mid-composition `input`, which re-arms it to the typed side. */
+    noteStart(): void;
+    /** The bytes the commit should write, or null to keep the DOM read verbatim. */
+    relocate(after: string, composedAt: number): {
+        raw: string;
+        caret: number;
+    } | null;
+    noteEnd(): void;
+}
+export declare function createCompositionSeat(deps: CompositionSeatDeps): CompositionSeat;

package/dist/components/blocks/text/composition-seat.js

@@ -0,0 +1,65 @@
+/**
+ * One composition's worth of seat inputs, captured at `compositionstart`. Both inputs the commit's
+ * relocation needs — the arrival side and the pending marks — belong to the caret the composition
+ * OPENED at, and the affinity re-arm has spent them by the time the composed run arrives.
+ */
+import { plainInsertionAt, relocateComposedRun } from './edge-seat';
+import { resolveMarkedInsertion } from './pending-mark-insert';
+export function createCompositionSeat(deps) {
+    // A single nullable capture rather than a stack: the window is compositionstart → the one
+    // commit compositionend drives.
+    let started = null;
+    return {
+        noteStart: () => {
+            started = {
+                before: deps.getDisplayText(),
+                affinity: deps.getAffinity(),
+                marks: deps.consumePendingMarks(),
+                range: deps.getRawSelection?.() ?? null,
+                committed: false
+            };
+        },
+        relocate: (after, composedAt) => {
+            if (started === null)
+                return null;
+            started.committed = true;
+            // A selection at the window's open makes this a range replace: the plain arms below
+            // cannot claim it, and the engine's literal replace strands the runs the range crossed.
+            if (started.range && started.range.start < started.range.end) {
+                const typed = replacedRangeInsertion(started.before, after, started.range);
+                if (typed === null)
+                    return null;
+                return deps.resolveRangeEdit?.(started.range, typed) ?? null;
+            }
+            // Marks beat the arrival side (live-mode.md § 4.2): a toggle is the newer instruction about the
+            // same bytes, so the affinity only answers when nothing was pending.
+            if (started.marks) {
+                const composed = plainInsertionAt(started.before, after, composedAt);
+                const marked = composed === null
+                    ? null
+                    : resolveMarkedInsertion(started.before, composedAt, composed, started.marks, deps.getInlines());
+                if (marked)
+                    return marked;
+            }
+            return relocateComposedRun(started.before, after, composedAt, deps.getInlines(), started.affinity, deps.getScreen());
+        },
+        noteEnd: () => {
+            if (started && !started.committed && started.marks) {
+                deps.restorePendingMarks(started.marks);
+            }
+            started = null;
+        }
+    };
+}
+/** The run the commit's read put over `range`, or null when the read is not a replacement of
+ *  exactly that span — then nothing here knows what the engine did, and verbatim is honest. */
+function replacedRangeInsertion(before, after, range) {
+    const length = after.length - before.length + (range.end - range.start);
+    if (length < 0 || range.end > before.length)
+        return null;
+    if (after.slice(0, range.start) !== before.slice(0, range.start))
+        return null;
+    if (after.slice(range.start + length) !== before.slice(range.end))
+        return null;
+    return after.slice(range.start, range.start + length);
+}

package/dist/components/blocks/text/construct-edge-delete.d.ts

@@ -0,0 +1,47 @@
+/**
+ * What a destructive key takes at an inline construct's unpainted delimiter run: the adjacent
+ * CONTENT character, plus the delimiters the cut leaves enclosing nothing (live-mode.md § 4.4
+ * `autoUnwrapOnEmpty`). Bytes that read right can parse wrong, so a candidate is written only once
+ * a re-parse says the reader lost exactly what the cut aimed at.
+ */
+import { type ContentRange } from '../../../core/inline';
+import { type VisibilityContext } from '../../../core/inline/visibility';
+import type { InlineNode } from '../../../core/nodes';
+export type DeleteDirection = 'backward' | 'forward';
+/** Named fields rather than a positional row: `display`, the two ranges and the caret are all
+ *  offsets into the same string, and a swapped pair would type-check. */
+export interface EdgeDeletionQuery {
+    /** The block's display bytes — its raw without the trailing line ending. */
+    display: string;
+    /** The bytes the block's own kind calls content; a cut never reaches past them. */
+    content: ContentRange;
+    caret: number;
+    direction: DeleteDirection;
+    /** How the block reads on screen. Required, so a second caller cannot inherit the hiding
+     *  assumption by silence. */
+    screen: VisibilityContext;
+    /** The inline tree the render painted from, so the runs skipped here are the runs hidden. */
+    inlines: readonly InlineNode[];
+    /** What the caller installs the rewrite as, which is what the candidate is read back as.
+     *  Required for the same reason `screen` is: a cell's text is never a block. */
+    installedAs: EdgeDeletionSurface;
+}
+/** A prose surface installs a block; a table cell installs cell text, whose bytes read as a list or
+ *  a quote the moment they open with `- ` or `> ` though the cell paints neither. */
+export type EdgeDeletionSurface = 'block' | 'cell';
+export interface EdgeDeletionWrite {
+    /** The block's whole display bytes after the cut. */
+    raw: string;
+    caret: number;
+}
+/** The press is this arm's but no rewrite parses back: taking nothing is the only answer that
+ *  keeps the markers off screen, since the engine's version paints them. */
+export interface EdgeDeletionSwallow {
+    swallow: true;
+}
+export type EdgeDeletion = EdgeDeletionWrite | EdgeDeletionSwallow;
+/**
+ * What a destructive key at `caret` does, or null when the press is not this arm's — nothing
+ * content-side of the caret, or a cut with no hidden run beside it, which the engine gets right.
+ */
+export declare function resolveEdgeDeletion(query: EdgeDeletionQuery): EdgeDeletion | null;

package/dist/components/blocks/text/construct-edge-delete.js

@@ -0,0 +1,164 @@
+/**
+ * What a destructive key takes at an inline construct's unpainted delimiter run: the adjacent
+ * CONTENT character, plus the delimiters the cut leaves enclosing nothing (live-mode.md § 4.4
+ * `autoUnwrapOnEmpty`). Bytes that read right can parse wrong, so a candidate is written only once
+ * a re-parse says the reader lost exactly what the cut aimed at.
+ */
+import { constructContentRange, inlineDescendants, parseInline } from '../../../core/inline';
+import { CONTENT_VISIBILITY, renderedText } from '../../../core/inline/visibility';
+import { getInlineConstructPolicy } from '../../../schema/inline-construct-policy';
+import { removesExactly, soleProseReparse } from './screen-diff';
+/**
+ * What a destructive key at `caret` does, or null when the press is not this arm's — nothing
+ * content-side of the caret, or a cut with no hidden run beside it, which the engine gets right.
+ */
+export function resolveEdgeDeletion(query) {
+    // Painted delimiters are bytes the reader saw, so no run here is this arm's to protect and the
+    // license to drop one (live-mode.md § 2) does not reach: the press is the engine's. Every
+    // oracle call below is past this gate, which is why they can all take the content reading.
+    if (query.screen.chromePaints)
+        return null;
+    const { display, content, caret, direction } = query;
+    const constructs = policyConstructs(query.inlines);
+    const target = deletionTarget(display, constructs, content, caret, direction);
+    if (!target)
+        return null;
+    // The adjacency that decides is the deleted SPAN's, not the caret's: the engine deletes from
+    // where the byte is. With no run beside the cut the press stays with the engine, which owns
+    // grapheme and IME behavior.
+    const plain = expandThroughEmptied(constructs, target);
+    const native = nativeCut(caret, direction);
+    const touchesHiddenRun = isDelimiterByte(constructs, target.start - 1) || isDelimiterByte(constructs, target.end);
+    if (!touchesHiddenRun && plain.start === native.start && plain.end === native.end)
+        return null;
+    const before = visibleText(display, query.installedAs);
+    if (before === null)
+        return null;
+    const removed = target.atomic
+        ? renderedText([target.atomic], display, CONTENT_VISIBILITY)
+        : display.slice(target.start, target.end);
+    for (const cut of [plain, widenThroughRuns(constructs, plain)]) {
+        const raw = display.slice(0, cut.start) + display.slice(cut.end);
+        const after = visibleText(raw, query.installedAs);
+        if (after === null || !removesExactly(before, after, removed))
+            continue;
+        // Backward lands where the cut opened; forward keeps the caret where it was, which the cut
+        // only moves when it swallowed delimiters ahead of it.
+        return { raw, caret: direction === 'backward' ? cut.start : Math.min(caret, cut.start) };
+    }
+    return { swallow: true };
+}
+function nativeCut(caret, direction) {
+    return direction === 'backward'
+        ? { start: caret - 1, end: caret }
+        : { start: caret, end: caret + 1 };
+}
+/**
+ * The first thing the reader can see on `direction`'s side of the caret: delimiter bytes are
+ * stepped over, an atomic run is taken whole, and the walk stops at the content range because the
+ * block's own structural bytes are not this arm's to touch.
+ */
+function deletionTarget(display, constructs, content, caret, direction) {
+    const step = direction === 'backward' ? -1 : 1;
+    for (let at = direction === 'backward' ? caret - 1 : caret; at >= content.start && at < content.end; at += step) {
+        const atomic = constructs.find((c) => !c.content && covers(c.node, at));
+        if (atomic)
+            return { start: atomic.node.start, end: atomic.node.end, atomic: atomic.node };
+        if (!isDelimiterByte(constructs, at))
+            return { ...codePointAt(display, at), atomic: null };
+    }
+    return null;
+}
+/** The whole code point `at` belongs to. Half a surrogate pair is not a character, and this arm
+ *  claims presses beside a hidden run wherever they land — emoji included. */
+function codePointAt(display, at) {
+    const start = isLowSurrogate(display, at) && isHighSurrogate(display, at - 1) ? at - 1 : at;
+    return { start, end: isHighSurrogate(display, start) ? start + 2 : start + 1 };
+}
+function isHighSurrogate(display, at) {
+    const code = display.charCodeAt(at);
+    return code >= 0xd800 && code <= 0xdbff;
+}
+function isLowSurrogate(display, at) {
+    const code = display.charCodeAt(at);
+    return code >= 0xdc00 && code <= 0xdfff;
+}
+/**
+ * The second reading of a press whose plain cut does not parse back: take the delimiter runs the
+ * cut now sits between with it, the "these two constructs become one" a reader sees when the
+ * character between them goes. Verified against the SCREEN, not the structure.
+ */
+function widenThroughRuns(constructs, cut) {
+    let { start, end } = cut;
+    while (isDelimiterByte(constructs, start - 1))
+        start--;
+    while (isDelimiterByte(constructs, end))
+        end++;
+    return { start, end };
+}
+/** A pair left around nothing is invisible residue, so a construct the cut empties goes with it —
+ *  repeatedly, since dropping the inner pair can empty its parent. */
+function expandThroughEmptied(constructs, target) {
+    const cut = { start: target.start, end: target.end };
+    let grew = true;
+    while (grew) {
+        grew = false;
+        for (const { node, content, autoUnwrapOnEmpty } of constructs) {
+            if (!autoUnwrapOnEmpty || !content)
+                continue;
+            if (content.start < cut.start || content.end > cut.end)
+                continue;
+            if (node.start >= cut.start && node.end <= cut.end)
+                continue;
+            cut.start = Math.min(cut.start, node.start);
+            cut.end = Math.max(cut.end, node.end);
+            grew = true;
+        }
+    }
+    return cut;
+}
+/** Only kinds the policy table names take part: an unpolicied construct's bytes are read as
+ *  ordinary content, which is what native already treats them as. */
+function policyConstructs(inlines) {
+    const found = [];
+    for (const node of inlineDescendants(inlines)) {
+        const policy = getInlineConstructPolicy(node.kind);
+        if (!policy)
+            continue;
+        found.push({
+            node,
+            content: constructContentRange(node),
+            autoUnwrapOnEmpty: policy.autoUnwrapOnEmpty
+        });
+    }
+    return found;
+}
+function covers(node, at) {
+    return at >= node.start && at < node.end;
+}
+function isDelimiterByte(constructs, at) {
+    return constructs.some(({ node, content }) => content !== null &&
+        ((at >= node.start && at < content.start) || (at >= content.end && at < node.end)));
+}
+// ── Verification ─────────────────────────────────────────────────────────────
+/**
+ * What a reader sees, asked of the thing that paints it, over the bytes read back the way `surface`
+ * installs them — null where they do not read back at all. The content reading, not the block's
+ * own: a cut that empties a construct folds its chrome into view, and the diff would read that
+ * arrival as bytes lost; sound because the painting-chrome case returned at the door.
+ */
+function visibleText(raw, surface) {
+    // Cell text is never a block, so it reads as its inline content and nothing else can refuse it.
+    if (surface === 'cell')
+        return renderedText(parseInline(raw, 0, raw.length), raw, CONTENT_VISIBILITY);
+    // A cut that empties the block is the one candidate with no block to read: emptied is a shape
+    // the reload keeps, so it answers for itself rather than through the parser.
+    if (raw === '')
+        return '';
+    // A candidate that re-reads as another block is not what the caller is about to install: a cut
+    // can abut two literal runs into a fence opener, which on reload swallows every block below.
+    const sole = soleProseReparse(raw);
+    if (sole === null)
+        return null;
+    return renderedText(sole.nodes, sole.block.raw, CONTENT_VISIBILITY);
+}

package/dist/components/blocks/text/construct-reveal.d.ts

@@ -0,0 +1,39 @@
+/**
+ * preview-inline's construct-reveal trigger: an inline construct's markers stay CSS-hidden until
+ * the caret enters its INCLUSIVE `[start, end]`, revealing the whole enclosing chain. Reveal is a
+ * class flip on `data-construct-*` spans, so the DOM text never changes and raw offsets survive it
+ * (spec: the preview-inline-affinity e2e requirement).
+ */
+import type { InlineNode } from '../../../core/nodes';
+import type { NodeView } from '../../../core/node-views';
+import type { PresentationMode } from '../../../presentation-mode';
+import type { LinkReferenceResolverRef } from '../../../editor-keys';
+/**
+ * Every revealable construct whose inclusive `[start, end]` contains `offset`, outermost
+ * first; at a boundary shared by adjacent siblings both are collected.
+ */
+export declare function constructChainAtOffset(nodes: InlineNode[], offset: number): InlineNode[];
+export interface ConstructRevealDeps {
+    get node(): NodeView;
+    get linkRef(): LinkReferenceResolverRef | undefined;
+    getEl: () => HTMLElement | null;
+    getAmbientLength: () => number;
+    getPresentationMode: () => PresentationMode;
+    /** Cross-block selections freeze the reveal state, so a sweep anchored in revealed
+     *  marker text keeps its layout. */
+    isCrossBlock: () => boolean;
+}
+export interface ConstructReveal {
+    /** Re-evaluate the caret chain and flip marker classes to match. `force` after a
+     *  rebuild: fresh spans carry no reveal class even on an unchanged chain key. */
+    update(force?: boolean): void;
+    /** Synchronous keydown backstop, reveal-only: Chromium prioritizes input events over
+     *  normal tasks, so rapid arrows outrun the selectionchange reveal and would step
+     *  against still-folded markers. Reveals the caret's chain plus `delta`'s (0 = neither). */
+    prepareStep(delta: -1 | 0 | 1): void;
+    /** Keydown wiring for `prepareStep`. Owns the key vocabulary so the component stays
+     *  free of destructive-key literals, which G4.12 scans for as interceptor shape;
+     *  this module holds no preventDefault and consumes nothing. */
+    prepareForKeydown(e: KeyboardEvent): void;
+}
+export declare function createConstructReveal(deps: ConstructRevealDeps): ConstructReveal;

package/dist/components/blocks/text/construct-reveal.js

@@ -0,0 +1,164 @@
+/**
+ * preview-inline's construct-reveal trigger: an inline construct's markers stay CSS-hidden until
+ * the caret enters its INCLUSIVE `[start, end]`, revealing the whole enclosing chain. Reveal is a
+ * class flip on `data-construct-*` spans, so the DOM text never changes and raw offsets survive it
+ * (spec: the preview-inline-affinity e2e requirement).
+ */
+import { tick } from 'svelte';
+import { inlineDescendants } from '../../../core/inline';
+import { resolvedInlineContent } from '../../../core/inline/inline-cache';
+import { isRevealableInlineKind } from '../../../schema/inline-construct-policy';
+import { toClampedRawOffset } from '../../../cursor/coordinate-spaces';
+import { CONSTRUCT_REVEAL_CLASS, domTextOffsetAtNode } from '../../../cursor/widget-offset';
+import { isInteractionTraceEnabled, traceRevealOpen, traceRevealFold } from '../../../debug/interaction-trace';
+// ── Chain math (pure) ────────────────────────────────────────────────────────
+/**
+ * Every revealable construct whose inclusive `[start, end]` contains `offset`, outermost
+ * first; at a boundary shared by adjacent siblings both are collected.
+ */
+export function constructChainAtOffset(nodes, offset) {
+    // A child lies inside its parent's range, so a node that misses the offset prunes its subtree.
+    const holds = (node) => offset >= node.start && offset <= node.end;
+    const chain = [];
+    for (const node of inlineDescendants(nodes, holds)) {
+        if (holds(node) && isRevealableInlineKind(node.kind))
+            chain.push(node);
+    }
+    return chain;
+}
+export function createConstructReveal(deps) {
+    // Span refs go stale on rebuild: removing a class from a detached span is a harmless
+    // no-op, and `force` re-resolves against the fresh DOM.
+    let appliedChain = [];
+    let appliedSpans = [];
+    let appliedKey = '';
+    let foldRecheckQueued = false;
+    function chainKey(chain) {
+        return chain.map((n) => `${n.start}:${n.end}`).join(',');
+    }
+    /** Caret raw offset while the mode is on and the caret sits in this block. */
+    function caretOffset() {
+        const el = deps.getEl();
+        if (!el || deps.getPresentationMode() !== 'preview-inline')
+            return null;
+        const sel = window.getSelection();
+        if (!sel || sel.rangeCount === 0 || !sel.focusNode || !el.contains(sel.focusNode))
+            return null;
+        return toClampedRawOffset(domTextOffsetAtNode(el, sel.focusNode, sel.focusOffset), deps.getAmbientLength());
+    }
+    function inlines() {
+        return resolvedInlineContent(deps.node, deps.linkRef);
+    }
+    const toEntry = (n) => ({ kind: n.kind, start: n.start, end: n.end });
+    /** The chain the current selection asks for; [] when nothing contains the caret. */
+    function evaluateChain() {
+        const offset = caretOffset();
+        if (offset === null)
+            return [];
+        return constructChainAtOffset(inlines(), offset).map(toEntry);
+    }
+    function traceTransitions(prev, next) {
+        if (!isInteractionTraceEnabled())
+            return;
+        const id = (n) => `${n.kind}:${n.start}-${n.end}`;
+        const prevIds = new Set(prev.map(id));
+        const nextIds = new Set(next.map(id));
+        for (const n of next)
+            if (!prevIds.has(id(n)))
+                traceRevealOpen('construct', id(n));
+        for (const n of prev)
+            if (!nextIds.has(id(n)))
+                traceRevealFold('caret-exit', id(n));
+    }
+    function apply(chain, key) {
+        const el = deps.getEl();
+        const next = [];
+        if (el) {
+            for (const node of chain) {
+                const spans = el.querySelectorAll(`[data-construct-start="${node.start}"][data-construct-end="${node.end}"]`);
+                for (const span of spans) {
+                    span.classList.add(CONSTRUCT_REVEAL_CLASS);
+                    next.push(span);
+                }
+            }
+        }
+        for (const span of appliedSpans) {
+            if (!next.includes(span))
+                span.classList.remove(CONSTRUCT_REVEAL_CLASS);
+        }
+        traceTransitions(appliedChain, chain);
+        appliedChain = chain;
+        appliedSpans = next;
+        appliedKey = key;
+    }
+    // A fold to no chain must survive a tick: cross-block entry clears the native selection
+    // before the cross-block flag flips, manufacturing a transient fold-shaped state.
+    function queueFoldRecheck() {
+        if (foldRecheckQueued)
+            return;
+        foldRecheckQueued = true;
+        void (async () => {
+            try {
+                await tick();
+            }
+            finally {
+                foldRecheckQueued = false;
+            }
+            if (deps.isCrossBlock())
+                return;
+            const chain = evaluateChain();
+            if (chain.length === 0 && appliedKey !== '')
+                apply([], '');
+        })();
+    }
+    function update(force = false) {
+        if (deps.isCrossBlock())
+            return;
+        const chain = evaluateChain();
+        const key = chainKey(chain);
+        if (force) {
+            apply(chain, key);
+            return;
+        }
+        if (key === appliedKey)
+            return;
+        if (key === '') {
+            queueFoldRecheck();
+            return;
+        }
+        apply(chain, key);
+    }
+    function prepareStep(delta) {
+        if (deps.isCrossBlock())
+            return;
+        const offset = caretOffset();
+        if (offset === null)
+            return;
+        const tree = inlines();
+        const chain = constructChainAtOffset(tree, offset).map(toEntry);
+        if (delta !== 0) {
+            for (const n of constructChainAtOffset(tree, offset + delta)) {
+                if (!chain.some((c) => c.start === n.start && c.end === n.end))
+                    chain.push(toEntry(n));
+            }
+        }
+        // Reveal-only: any fold an empty union implies belongs to the selection cadence.
+        if (chain.length === 0)
+            return;
+        const key = chainKey(chain);
+        if (key === appliedKey)
+            return;
+        apply(chain, key);
+    }
+    function prepareForKeydown(e) {
+        if (e.ctrlKey || e.metaKey || e.altKey)
+            return;
+        if (e.key === 'ArrowRight')
+            prepareStep(1);
+        else if (e.key === 'ArrowLeft')
+            prepareStep(-1);
+        else if (e.key === 'Backspace' || e.key === 'Delete')
+            prepareStep(0);
+    }
+    return { update, prepareStep, prepareForKeydown };
+}