@voithos-labs/aragonite 0.10.1

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

@@ -0,0 +1,197 @@
+/**
+ * Which side of a construct's unpainted marker run a typed byte belongs to: a run painted at zero
+ * width leaves one screen position naming two raw offsets. The kind's `edgeAffinity` policy answers
+ * first (a link never extends), the arrival affinity second — and the painter has the last word
+ * (live-mode.md § 2), since a seat that reads right can parse wrong.
+ */
+import { constructContentRange, inlineDescendants, parseInline } from '../../../core/inline';
+import { CONTENT_VISIBILITY, renderedText, visibleRuns } from '../../../core/inline/visibility';
+import { getInlineConstructPolicy } from '../../../schema/inline-construct-policy';
+import { insertsExactly } from './screen-diff';
+/**
+ * Where `typed` belongs when the caret sits at `caretOffset`, or null when the offset touches no
+ * construct marker run, the kind declares no policy, or no candidate earns the write. Declining is
+ * the honest fallback: the byte then lands at the caret, which is what the engine writes anyway.
+ */
+export function resolveEdgeSeat(caretOffset, inlines, affinity, raw, screen, typed) {
+    const runs = markerRuns(inlines, raw, screen);
+    const run = runAt(caretOffset, runs);
+    if (!run)
+        return null;
+    const policy = getInlineConstructPolicy(run.kind);
+    if (!policy)
+        return null;
+    const content = contentBounds(inlines);
+    const before = shown(raw, content.start, content.end);
+    const holds = (offset) => {
+        const candidate = raw.slice(0, offset) + typed + raw.slice(offset);
+        const after = shown(candidate, content.start, content.end + typed.length);
+        return insertsExactly(before, after, typed);
+    };
+    for (const offset of candidateOffsets(run, policy.edgeAffinity, affinity, caretOffset, runs)) {
+        // The walk's read and Chromium's insertion canonicalize the same way, so a verified
+        // `seat === caret` means native typing already lands where the seat wants it.
+        if (offset === caretOffset) {
+            if (holds(offset))
+                return null;
+            continue;
+        }
+        if (holds(offset))
+            return { offset, kind: run.kind };
+    }
+    return null;
+}
+/**
+ * The bytes a COMPOSITION commit should have written. `insertCompositionText` beforeinput is not
+ * cancelable, so the seat cannot intercept the keystroke and relocates the composed run once, on
+ * the commit that lands it. Null leaves the read as-is.
+ */
+export function relocateComposedRun(before, after, composedAt, inlines, affinity, screen) {
+    const composed = plainInsertionAt(before, after, composedAt);
+    if (composed === null)
+        return null;
+    const seat = resolveEdgeSeat(composedAt, inlines, affinity, before, screen, composed);
+    if (!seat)
+        return null;
+    return {
+        raw: before.slice(0, seat.offset) + composed + before.slice(seat.offset),
+        caret: seat.offset + composed.length
+    };
+}
+/** The text a commit's read added at `at`, or null when the read is not a plain insertion
+ *  there — a composition over a selection is a range op, and no seat claims a range. */
+export function plainInsertionAt(before, after, at) {
+    const length = after.length - before.length;
+    if (length <= 0 || at < 0 || at > before.length)
+        return null;
+    if (after.slice(0, at) !== before.slice(0, at))
+        return null;
+    if (after.slice(at + length) !== before.slice(at))
+        return null;
+    return after.slice(at, at + length);
+}
+/**
+ * Every raw offset the caret's screen position ADMITS — the seat's whole reach, and empty where no
+ * marker run touches the caret. A hidden run's hidden neighbours name the same position, so the
+ * stretch of abutting runs is one position and each boundary in it is a seat; an offset inside a
+ * run's own bytes is inside some construct's delimiters, which is where no byte belongs. A caret
+ * strictly inside a run is one such offset, so the reach can exclude the caret it was asked about.
+ */
+export function seatOffsetsAt(caretOffset, inlines, raw, screen) {
+    const runs = markerRuns(inlines, raw, screen);
+    const run = runAt(caretOffset, runs);
+    if (!run)
+        return [];
+    const offsets = screenPositionOffsets(run, runs);
+    return getInlineConstructPolicy(run.kind)?.edgeAffinity === 'never-extend'
+        ? offsets.filter((offset) => outsideSpan(run, offset))
+        : offsets;
+}
+function offsetForSide(run, side) {
+    if (side === 'near')
+        return run.start;
+    if (side === 'far')
+        return run.end;
+    return run.leading ? run.start : run.end;
+}
+const otherEnd = (run, side) => offsetForSide(run, side) === run.start ? run.end : run.start;
+/**
+ * The offsets to try, best first: the policy's side, then the run's other end — the split
+ * rebalancer's space-outside reading in the seat's terms, since a byte the run's inner side kills
+ * is one its outer side keeps. Then the byte-literal write, verified like any other candidate: a
+ * parse it rebinds is no reason to stop looking. The rest of the screen position ends the list,
+ * nearest the policy's side first, for the caret whose own construct has no answer to give.
+ */
+function candidateOffsets(run, edgeAffinity, affinity, caretOffset, runs) {
+    // Never-extend resolves like a line extreme: past the construct's delimiters, which is the
+    // run's near side at an opener and its far side at a closer. A symmetric pair follows the
+    // arrival, defaulting to the near side — the gdocs click default (live-mode.md § 4.2).
+    const side = edgeAffinity === 'never-extend' ? 'outside' : (affinity ?? 'near');
+    const preferred = offsetForSide(run, side);
+    const ranked = [preferred, otherEnd(run, side), caretOffset];
+    const rest = screenPositionOffsets(run, runs)
+        .filter((offset) => !ranked.includes(offset))
+        .sort((a, b) => Math.abs(a - preferred) - Math.abs(b - preferred));
+    const offsets = [...new Set([...ranked, ...rest])];
+    return edgeAffinity === 'never-extend' ? offsets.filter((o) => outsideSpan(run, o)) : offsets;
+}
+/** Whether `offset` lies outside the run's own construct. A `never-extend` row admits nothing
+ *  inside: half a URL is not a URL, half an escape is a literal backslash, and a destination the
+ *  mode never paints is one the painter cannot check. Stated over the SPAN rather than over the
+ *  run's inner end, since the screen position reaches an interior through a neighbour's run too. */
+const outsideSpan = (run, offset) => offset <= run.span.start || offset >= run.span.end;
+/** The stretch of abutting runs `run` belongs to, as the boundary offsets inside it. */
+function screenPositionOffsets(run, runs) {
+    let lo = run.start;
+    let hi = run.end;
+    for (let grew = true; grew;) {
+        grew = false;
+        for (const other of runs) {
+            if (other.start > hi || other.end < lo)
+                continue;
+            if (other.start < lo) {
+                lo = other.start;
+                grew = true;
+            }
+            if (other.end > hi) {
+                hi = other.end;
+                grew = true;
+            }
+        }
+    }
+    const bounds = new Set([lo, hi]);
+    for (const other of runs) {
+        if (other.start >= lo && other.start <= hi)
+            bounds.add(other.start);
+        if (other.end >= lo && other.end <= hi)
+            bounds.add(other.end);
+    }
+    return [...bounds];
+}
+/** The bytes the inline tree covers — the block's content range, read off the tree rather than
+ *  taken as a second parameter that could disagree with it. */
+function contentBounds(inlines) {
+    return { start: inlines[0].start, end: inlines[inlines.length - 1].end };
+}
+/** What a reader sees, asked of the thing that paints it (G4.33). The content reading, not the
+ *  block's own: this seam only ADDS bytes, so no reading of it licenses dropping one. */
+const shown = (raw, start, end) => renderedText(parseInline(raw, start, end), raw, CONTENT_VISIBILITY);
+/** Every construct marker run, in pre-order. */
+function markerRuns(inlines, raw, screen) {
+    const runs = [];
+    for (const node of inlineDescendants(inlines)) {
+        const content = constructContentRange(node) ?? paintedRange(node, raw, screen);
+        if (!content)
+            continue;
+        const span = { start: node.start, end: node.end };
+        if (node.start < content.start) {
+            runs.push({ start: node.start, end: content.start, leading: true, kind: node.kind, span });
+        }
+        if (content.end < node.end) {
+            runs.push({ start: content.end, end: node.end, leading: false, kind: node.kind, span });
+        }
+    }
+    return runs;
+}
+/**
+ * The run `offset` sits in, its own boundaries included — the LAST in pre-order, so the innermost
+ * construct at a shared boundary wins. INSIDE counts, not just the two ends: a doubled code fence
+ * is a run a caret can be handed the middle of.
+ */
+const runAt = (offset, runs) => runs.reduce((found, run) => (offset >= run.start && offset <= run.end ? run : found), null);
+/**
+ * What a CHILDLESS construct paints, as a range in the block's own bytes: the outer bounds of its
+ * visible runs, which such a construct has one contiguous stretch of — the precondition the two
+ * marker runs below are carved out of, held by `test/core/inline/painted-contiguity.property`.
+ * Asked of the render path rather than derived per kind, since which bytes a construct shows only
+ * the painter answers (G4.33), and in the block's OWN reading: where its chrome paints, the whole
+ * construct is on screen, no run is hidden, and the seat has nothing to relocate.
+ */
+function paintedRange(node, raw, screen) {
+    if (node.kind === 'text')
+        return null;
+    const painted = visibleRuns([node], raw, screen).filter((run) => run.visible && run.text !== '');
+    if (painted.length === 0)
+        return null;
+    return { start: painted[0].start, end: painted[painted.length - 1].end };
+}

package/dist/components/blocks/text/hidden-suffix.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Whether a block keeps structure PAST its content that the surface paints nothing for — today the
+ * setext underline. A merge past it concatenates it into view (`Title\n===` + `next` reparses to a
+ * paragraph showing `===next`), so the keydown dispatch consumes the press and the command arm
+ * declines it — one home, since the two ask from different coordinate sources (live-mode.md § 4.5).
+ */
+import type { NodeView } from '../../../core/node-views';
+/** `displayLength` is the caller's, not this module's: the component reads the DOM while a widget
+ *  reveal is open, where `node.raw` is stale by construction. */
+export declare function hidesStructuralSuffix(el: HTMLElement | null, node: NodeView, displayLength: number): boolean;

package/dist/components/blocks/text/hidden-suffix.js

@@ -0,0 +1,15 @@
+/**
+ * Whether a block keeps structure PAST its content that the surface paints nothing for — today the
+ * setext underline. A merge past it concatenates it into view (`Title\n===` + `next` reparses to a
+ * paragraph showing `===next`), so the keydown dispatch consumes the press and the command arm
+ * declines it — one home, since the two ask from different coordinate sources (live-mode.md § 4.5).
+ */
+import { getContentRange } from '../../../core/inline';
+import { revealsNoMarkers } from '../../../cursor/widget-offset';
+/** `displayLength` is the caller's, not this module's: the component reads the DOM while a widget
+ *  reveal is open, where `node.raw` is stale by construction. */
+export function hidesStructuralSuffix(el, node, displayLength) {
+    if (!el || !revealsNoMarkers(el))
+        return false;
+    return getContentRange(node).end < displayLength;
+}

package/dist/components/blocks/text/link-at-point.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Which link construct a pointer landed in, and how to find that construct again after an edit
+ * rebuilt the tree. The offset comes from the shared DOM↔raw walk and the construct from the
+ * reveal chain, so the card addresses exactly what the render path drew.
+ */
+import type { InlineNode } from '../../../core/nodes';
+import type { NodeView } from '../../../core/node-views';
+import type { LinkReferenceResolverRef } from '../../../editor-keys';
+/** Both DOM shapes a bracketed link takes: `a` for an allowed scheme, `span.md-link-blocked` for a
+ *  rejected one — and a blocked link is precisely the one a user opens the card to fix. */
+export declare const LINK_ELEMENT_SELECTOR = ".md-link-content";
+/** Path plus construct start, never a node reference: every commit rebuilds the inline tree and the
+ *  DOM under it, so an open card re-resolves from this identity after each edit. */
+export interface LinkTarget {
+    path: number[];
+    sourceStart: number;
+}
+export interface LinkPointResolution {
+    target: LinkTarget;
+    link: InlineNode;
+}
+export interface LinkPointQuery {
+    /** The block's content element — the walk container the raw offset is measured in. */
+    contentEl: HTMLElement;
+    block: NodeView;
+    path: number[];
+    linkRef?: LinkReferenceResolverRef;
+}
+/** The link the caret sits inside, read after the pointer has seated it. */
+export declare function resolveLinkAtPoint(query: LinkPointQuery): LinkPointResolution | null;
+/** The construct an open card is anchored to, re-read from the live tree; null once an edit moved
+ *  or removed it. */
+export declare function linkConstructAt(block: NodeView, sourceStart: number, linkRef?: LinkReferenceResolverRef): InlineNode | null;

package/dist/components/blocks/text/link-at-point.js

@@ -0,0 +1,47 @@
+/**
+ * Which link construct a pointer landed in, and how to find that construct again after an edit
+ * rebuilt the tree. The offset comes from the shared DOM↔raw walk and the construct from the
+ * reveal chain, so the card addresses exactly what the render path drew.
+ */
+import { ambientLengthOf } from '../../../ambient/ambient-dom';
+import { inlineDescendants } from '../../../core/inline';
+import { resolvedInlineContent } from '../../../core/inline/inline-cache';
+import { toClampedRawOffset } from '../../../cursor/coordinate-spaces';
+import { domTextOffsetAtNode } from '../../../cursor/widget-offset';
+import { isCardEditableInlineKind } from '../../../schema/inline-construct-policy';
+import { constructChainAtOffset } from './construct-reveal';
+/** Both DOM shapes a bracketed link takes: `a` for an allowed scheme, `span.md-link-blocked` for a
+ *  rejected one — and a blocked link is precisely the one a user opens the card to fix. */
+export const LINK_ELEMENT_SELECTOR = '.md-link-content';
+/** The link the caret sits inside, read after the pointer has seated it. */
+export function resolveLinkAtPoint(query) {
+    const offset = caretRawOffset(query.contentEl);
+    if (offset === null)
+        return null;
+    const inlines = resolvedInlineContent(query.block, query.linkRef);
+    // Outermost-first, so the last card-editable construct in the chain is the one whose bytes
+    // enclose the pointer most tightly. The chain itself is the reveal's, which admits only
+    // revealable kinds, so an autolink never reaches this filter either way.
+    const link = constructChainAtOffset(inlines, offset).filter(isCardEditable).at(-1);
+    if (link === undefined)
+        return null;
+    return { target: { path: query.path, sourceStart: link.start }, link };
+}
+const isCardEditable = (node) => isCardEditableInlineKind(node.kind);
+/** The construct an open card is anchored to, re-read from the live tree; null once an edit moved
+ *  or removed it. */
+export function linkConstructAt(block, sourceStart, linkRef) {
+    for (const node of inlineDescendants(resolvedInlineContent(block, linkRef))) {
+        if (isCardEditable(node) && node.start === sourceStart)
+            return node;
+    }
+    return null;
+}
+function caretRawOffset(contentEl) {
+    const sel = window.getSelection();
+    if (!sel || sel.rangeCount === 0 || !sel.focusNode)
+        return null;
+    if (!contentEl.contains(sel.focusNode))
+        return null;
+    return toClampedRawOffset(domTextOffsetAtNode(contentEl, sel.focusNode, sel.focusOffset), ambientLengthOf(contentEl));
+}

package/dist/components/blocks/text/link-source-bytes.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Where a link edit becomes bytes: the seam every link write path calls (G4.34), and under it the
+ * GFM branch. A candidate is written only once the RENDER PATH says the reader sees exactly what
+ * they saw before — a destination that breaks its own construct surfaces as literal source, which
+ * a private walk over the parse cannot see.
+ */
+import type { LinkReferenceResolver } from '../../../core/inline/link-reference-resolver';
+import type { InlineNode } from '../../../core/nodes';
+export interface LinkFields {
+    /** RAW inner bytes of the link text. Never re-escaped: the text holds whole nested constructs,
+     *  and re-emitting them from the parse would rewrite bytes the user never touched. */
+    text: string;
+    url: string;
+    title?: string;
+    /** Reference forms only: the raw tail after the text's `]` (`[ref]`, `[]`, or empty for the
+     *  shortcut form). Present preserves the reference; absent inlines the destination. */
+    reference?: string;
+}
+/**
+ * Bytes to splice over `link`'s range, or `null` when the edit must be declined. **Every link
+ * write path goes through here** (G4.34): a node an inline rung claimed carries no `rewriteLink`
+ * hook, so emitting built-in grammar over its bytes would destroy the author's syntax.
+ */
+export declare function buildLinkEditBytes(link: InlineNode, display: string, fields: LinkFields, resolver?: LinkReferenceResolver): string | null;
+/** Bytes that unwrap `link` to the text the reader already sees — remove-link. An autolink has no
+ *  brackets to drop, so its removal is the same escape rewrite a re-linking text needs. */
+export declare function buildLinkUnwrapBytes(link: InlineNode, display: string, resolver?: LinkReferenceResolver): string | null;
+/** Bytes that mint `[text](url)` over `[start, end)` — the card's create half. Declines an empty
+ *  destination, a range crossing another construct's bytes, and any candidate the render check
+ *  refuses (a neighbouring `!` would turn the wrap into an image). */
+export declare function buildLinkWrapBytes(display: string, start: number, end: number, url: string, resolver?: LinkReferenceResolver): string | null;
+/** True when `[start, end)` holds only bytes safe to become link text. Wrapping inside or across
+ *  another construct is a policy question create does not answer — it declines. */
+export declare function canWrapRangeAsLink(display: string, start: number, end: number, resolver?: LinkReferenceResolver): boolean;
+/** The fields the card edits, read off the source bytes: `url`/`title` are decoded on the node,
+ *  but the text and the reference tail must survive as the author wrote them. */
+export declare function linkFieldsFromInline(link: InlineNode, display: string): LinkFields;

package/dist/components/blocks/text/link-source-bytes.js

@@ -0,0 +1,161 @@
+/**
+ * Where a link edit becomes bytes: the seam every link write path calls (G4.34), and under it the
+ * GFM branch. A candidate is written only once the RENDER PATH says the reader sees exactly what
+ * they saw before — a destination that breaks its own construct surfaces as literal source, which
+ * a private walk over the parse cannot see.
+ */
+import { inlineDescendants, parseInline } from '../../../core/inline';
+import { encodeDestination, escapeTitle } from '../../../core/inline/destination-bytes';
+import { CONTENT_VISIBILITY, renderedText } from '../../../core/inline/visibility';
+import { devWarn } from '../../../dev-warn';
+/**
+ * Bytes to splice over `link`'s range, or `null` when the edit must be declined. **Every link
+ * write path goes through here** (G4.34): a node an inline rung claimed carries no `rewriteLink`
+ * hook, so emitting built-in grammar over its bytes would destroy the author's syntax.
+ */
+export function buildLinkEditBytes(link, display, fields, resolver) {
+    if (declineClaimed(link, 'edit'))
+        return null;
+    return verified(buildLinkSourceBytes(fields), link.start, link.end, display, resolver);
+}
+/** Bytes that unwrap `link` to the text the reader already sees — remove-link. An autolink has no
+ *  brackets to drop, so its removal is the same escape rewrite a re-linking text needs. */
+export function buildLinkUnwrapBytes(link, display, resolver) {
+    if (declineClaimed(link, 'remove'))
+        return null;
+    const [textStart, textEnd] = textRange(link, display);
+    const plain = display.slice(textStart, textEnd);
+    return verified(escapeRelinkingText(plain, link, display, resolver), link.start, link.end, display, resolver);
+}
+/** Bytes that mint `[text](url)` over `[start, end)` — the card's create half. Declines an empty
+ *  destination, a range crossing another construct's bytes, and any candidate the render check
+ *  refuses (a neighbouring `!` would turn the wrap into an image). */
+export function buildLinkWrapBytes(display, start, end, url, resolver) {
+    if (url.trim() === '' || !canWrapRangeAsLink(display, start, end, resolver))
+        return null;
+    // A bare bracket would close the construct early; an existing `\x` pair passes through whole.
+    const text = display
+        .slice(start, end)
+        .replace(/\\[\s\S]|[[\]]/g, (m) => (m.length === 2 ? m : '\\' + m));
+    return verified(`[${text}](${encodeDestination(url)})`, start, end, display, resolver);
+}
+const WRAP_SAFE_KINDS = new Set(['text', 'escape', 'entityReference']);
+/** True when `[start, end)` holds only bytes safe to become link text. Wrapping inside or across
+ *  another construct is a policy question create does not answer — it declines. */
+export function canWrapRangeAsLink(display, start, end, resolver) {
+    if (start >= end || end > display.length)
+        return false;
+    return flattenInline(parseInline(display, 0, display.length, resolver)).every((n) => WRAP_SAFE_KINDS.has(n.kind) || n.end <= start || n.start >= end);
+}
+/** The fields the card edits, read off the source bytes: `url`/`title` are decoded on the node,
+ *  but the text and the reference tail must survive as the author wrote them. */
+export function linkFieldsFromInline(link, display) {
+    const [textStart, textEnd] = textRange(link, display);
+    return {
+        text: display.slice(textStart, textEnd),
+        url: link.url ?? '',
+        ...(link.title !== undefined ? { title: link.title } : {}),
+        ...(link.label !== undefined ? { reference: display.slice(textEnd + 1, link.end) } : {})
+    };
+}
+// ── The GFM serializer ──────────────────────────────────────────────────────
+/** The built-in grammar's inverse. Reach it through the seam above, the only caller entitled to
+ *  decide these bytes are GFM's to write. */
+function buildLinkSourceBytes(fields) {
+    if (fields.reference !== undefined)
+        return `[${fields.text}]${fields.reference}`;
+    const title = fields.title !== undefined ? ` "${escapeTitle(fields.title)}"` : '';
+    return `[${fields.text}](${encodeDestination(fields.url)}${title})`;
+}
+// ── Verification ────────────────────────────────────────────────────────────
+function declineClaimed(link, what) {
+    const claim = link.syntaxClaim;
+    if (!claim)
+        return false;
+    devWarn('link-edit', `${what} declined: the "${claim.prefix}" inline rung owns these bytes and registered no link rewriter`);
+    return true;
+}
+/** What a reader SEES for `raw`, asked of the thing that paints it. The content reading, not the
+ *  block's own: the card edits a destination the chrome may be painting, and a diff against the
+ *  screen would refuse every such edit as a visible change. The write splices bytes for bytes and
+ *  drops none, so no reading of it licenses losing one the reader saw. */
+function visibleText(raw, resolver) {
+    return renderedText(parseInline(raw, 0, raw.length, resolver), raw, CONTENT_VISIBILITY);
+}
+/** A candidate is bytes only if splicing it over `[start, end)` leaves the reader's text
+ *  untouched — the write moves bytes nobody saw, so any visible change is the construct broken. */
+function verified(candidate, start, end, display, resolver) {
+    if (candidate === null)
+        return null;
+    const before = visibleText(display, resolver);
+    const after = visibleText(spliced(candidate, start, end, display), resolver);
+    return before === after ? candidate : null;
+}
+function spliced(candidate, start, end, display) {
+    return display.slice(0, start) + candidate + display.slice(end);
+}
+// ── Text ranges and the re-link escape ──────────────────────────────────────
+/** The bytes between a construct's opener and its hidden tail: `[…]` for a link, the angle
+ *  brackets for an autolink, the whole node for the bare forms. */
+function textRange(link, display) {
+    if (link.kind === 'autolink') {
+        const angle = display[link.start] === '<' && display[link.end - 1] === '>';
+        return angle ? [link.start + 1, link.end - 1] : [link.start, link.end];
+    }
+    const children = link.children ?? [];
+    if (children.length === 0) {
+        const close = display.indexOf(']', link.start);
+        return [link.start + 1, close === -1 ? link.end : close];
+    }
+    return [children[0].start, children[children.length - 1].end];
+}
+const TRIGGER_ESCAPE = [
+    [/^https?:/i, ':'],
+    [/^www\./i, '.'],
+    [/^[^@]*@/, '@']
+];
+/**
+ * Unwrapping `[www.x.com](u)` hands the bare-autolink pass a match it did not have before, and the
+ * link the user removed comes straight back. Escaping the byte that triggers the match kills it
+ * without changing one character the reader sees.
+ */
+function escapeRelinkingText(text, link, display, resolver) {
+    let candidate = text;
+    // One pass per surviving autolink; the text is finite and each pass kills one match.
+    for (let guard = 0; guard <= text.length; guard++) {
+        const offender = relinkedRange(candidate, link, display, resolver);
+        if (offender === null)
+            return candidate;
+        const escaped = escapeTrigger(candidate, offender);
+        if (escaped === null)
+            return null;
+        candidate = escaped;
+    }
+    return null;
+}
+/** The candidate-relative range of the first link the splice re-created, or null when clean. */
+function relinkedRange(candidate, link, display, resolver) {
+    const raw = spliced(candidate, link.start, link.end, display);
+    const end = link.start + candidate.length;
+    const found = flattenInline(parseInline(raw, 0, raw.length, resolver)).find((n) => (n.kind === 'link' || n.kind === 'autolink') && n.start < end && n.end > link.start);
+    if (!found)
+        return null;
+    // An offender reaching outside the spliced range is the surrounding text linking with it,
+    // which no escape inside the candidate can decide.
+    if (found.start < link.start || found.end > end)
+        return null;
+    return [found.start - link.start, found.end - link.start];
+}
+function escapeTrigger(candidate, [start, end]) {
+    const match = candidate.slice(start, end);
+    for (const [form, byte] of TRIGGER_ESCAPE) {
+        if (!form.test(match))
+            continue;
+        const at = match.indexOf(byte);
+        if (at === -1)
+            return null;
+        return candidate.slice(0, start + at) + '\\' + candidate.slice(start + at);
+    }
+    return null;
+}
+const flattenInline = (nodes) => [...inlineDescendants(nodes)];

package/dist/components/blocks/text/live-join-seam.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The live-mode join rewrite (live-mode.md § 4.5): a literal concatenation surfaces the runs a
+ * truncation left unpaired and the closer/opener pair a split's inverse abuts around nothing. Both
+ * are dropped here and nowhere else, and only once the joined block re-parses to ONE prose block
+ * showing what the two sides showed.
+ */
+import type { InlineNode } from '../../../core/nodes';
+import { type LiveJoinSeamCleaner } from '../../../schema/inline-construct-policy';
+export declare const cleanLiveJoinSeam: LiveJoinSeamCleaner;
+/**
+ * The `keep` side of `level`, rebuilt: a construct the cut crosses hands its place to its own
+ * clipped children. Exported for the depth pin, which has to reach the rebuild with a tree no
+ * side this deep could be rendered at.
+ */
+export declare function clipNodes(level: readonly InlineNode[], cut: number, keep: 'before' | 'after'): InlineNode[];