@voithos-labs/aragonite 0.10.1

package/dist/core/inline/scan/plugin-syntax.js

@@ -0,0 +1,150 @@
+/**
+ * Unstable-public hook for plugin inline syntax: a priority ladder mirroring `OPENER_PRIORITIES`.
+ * One trigger character plus an optional prefix beginning with it, dispatched low-priority-first
+ * so a plugin can outrank a built-in trigger on a longer prefix (footnotes' `[^` beating `[`).
+ * Reserved triggers hold pre-switch rungs, all others hold `default`-arm rungs (scan/index.ts).
+ */
+import { registerOnce } from '../../../schema/register-once';
+/** The priority ladder every registration prices against; lower is consulted first. */
+export const INLINE_PRIORITIES = {
+    /** Rungs consulted before a reserved trigger's built-in handling. */
+    prefixOverride: 40,
+    /** The switch's own anchor; not registerable. */
+    builtin: 50,
+    /** Default rung for bare-trigger registrations. */
+    plugin: 100
+};
+/**
+ * The characters `scanInline`'s switch claims. A bare registration on one would never fire; it
+ * needs a prefix rung priced below `builtin`. Kept in step with `./index.ts` by G4.18.
+ */
+const BUILTIN_TRIGGERS = new Set(['\\', '`', '&', '\n', '*', '_', '~', '[', ']', '!', '<']);
+/**
+ * Reserved triggers a registration makes visible to `needsScan` (scan/index.ts) instead, probed
+ * only while a rung lives on them. `!` is here rather than in `SPECIAL_CHARS` because making it
+ * unconditionally special would drag every prose `"Hello!"` through the full scan loop.
+ */
+const SCAN_PROBED_RESERVED = new Set(['!']);
+/**
+ * Reserved triggers with no route to the scan at all, so a prefix rung on one would be accepted
+ * yet never consulted: the silent no-op this seam exists to prevent. A construct needing `]`
+ * gives it a route first. Pinned against a SPECIAL_CHARS edit by G4.18.
+ */
+const REJECTED_RESERVED = new Set([']']);
+const NO_RUNGS = [];
+// Reserved-trigger prefix rungs (pre-switch) live apart from every other trigger's rungs
+// (`default` arm) so each dispatch path reads one map and its empty gate is one `size` check.
+const reservedRegistry = new Map();
+const unreservedRegistry = new Map();
+// Triggers the fast bail (`needsScan`, scan/index.ts) must visit while a rung lives on them.
+// Maintained at registration, so a rung on a trigger `SPECIAL_CHARS` already visits costs nothing.
+const scanProbeTriggers = new Set();
+// ── Registration ───────────────────────────────────────────────────────────────
+export function registerInlineSyntax(trigger, recognizer, options) {
+    if (trigger.length !== 1) {
+        throw new Error('registerInlineSyntax: trigger must be a single character');
+    }
+    const { prefix, priority = INLINE_PRIORITIES.plugin, rewriteImage } = options ?? {};
+    if (prefix !== undefined && (prefix.length < 2 || !prefix.startsWith(trigger))) {
+        throw new Error(`registerInlineSyntax: prefix ${JSON.stringify(prefix)} must begin with the trigger ` +
+            `${JSON.stringify(trigger)} and be at least two characters`);
+    }
+    const reserved = BUILTIN_TRIGGERS.has(trigger);
+    if (reserved) {
+        // Pinned contract: keep the message verbatim. A reserved trigger is reachable only
+        // through a prefix rung priced below the switch anchor.
+        if (prefix === undefined) {
+            throw new Error(`registerInlineSyntax: ${JSON.stringify(trigger)} is claimed by the built-in scanner, ` +
+                `which dispatches it before the plugin registry — the recognizer would never fire`);
+        }
+        if (REJECTED_RESERVED.has(trigger)) {
+            throw new Error(`registerInlineSyntax: reserved trigger ${JSON.stringify(trigger)} is skipped by the ` +
+                `scanner's fast bail (absent from SPECIAL_CHARS in scan/index.ts; it matters only ` +
+                `inside "["-bearing ranges), so a prefix rung on it would never fire in plain text — ` +
+                `make the trigger scan-visible or scan-probed before registering`);
+        }
+        if (priority >= INLINE_PRIORITIES.builtin) {
+            throw new Error(`registerInlineSyntax: reserved trigger ${JSON.stringify(trigger)} needs a priority ` +
+                `below the built-in boundary (${INLINE_PRIORITIES.builtin}) so its prefix outranks ` +
+                `the built-in scanner; got ${priority}`);
+        }
+    }
+    const effectivePrefix = prefix ?? trigger;
+    const registry = reserved ? reservedRegistry : unreservedRegistry;
+    const existing = registry.get(trigger);
+    const isDuplicate = existing?.some((r) => r.prefix === effectivePrefix && r.priority === priority) ?? false;
+    registerOnce(isDuplicate, () => {
+        upsertRung(registry, trigger, {
+            recognizer,
+            prefix: effectivePrefix,
+            priority,
+            rewriteImage
+        });
+        // A rung on a trigger the fast bail would skip must make the scan visit it,
+        // or the recognizer is the silent no-op this seam refuses to accept.
+        if (!reserved || SCAN_PROBED_RESERVED.has(trigger))
+            scanProbeTriggers.add(trigger);
+    }, `registerInlineSyntax: ${JSON.stringify(trigger)} already registered at prefix ` +
+        `${JSON.stringify(effectivePrefix)}, priority ${priority}`);
+}
+// Kept sorted at insert so dispatch order does not depend on registration order.
+function compareRungs(a, b) {
+    if (a.priority !== b.priority)
+        return a.priority - b.priority;
+    if (a.prefix.length !== b.prefix.length)
+        return b.prefix.length - a.prefix.length;
+    return a.prefix < b.prefix ? -1 : a.prefix > b.prefix ? 1 : 0;
+}
+// Overwriting a matching (prefix, priority) rung is the dev-server replace path.
+function upsertRung(registry, trigger, rung) {
+    const rungs = registry.get(trigger);
+    if (!rungs) {
+        registry.set(trigger, [rung]);
+        return;
+    }
+    const at = rungs.findIndex((r) => r.prefix === rung.prefix && r.priority === rung.priority);
+    if (at >= 0)
+        rungs[at] = rung;
+    else {
+        rungs.push(rung);
+        rungs.sort(compareRungs);
+    }
+}
+// ── Dispatch accessors ───────────────────────────────────────────────────────────
+/**
+ * Whether the built-in scanner claims `trigger` through a `case` arm. A rung on one is consulted
+ * BEFORE that arm, so it owes the overlap a decline; the conformance kit refuses it an exemption.
+ */
+export function isReservedInlineTrigger(trigger) {
+    return BUILTIN_TRIGGERS.has(trigger);
+}
+/** Rungs for a trigger in dispatch order, reserved-aware. Empty when none. */
+export function getInlineRungs(trigger) {
+    const registry = BUILTIN_TRIGGERS.has(trigger) ? reservedRegistry : unreservedRegistry;
+    return registry.get(trigger) ?? NO_RUNGS;
+}
+export function getUnreservedRungs(char) {
+    return unreservedRegistry.get(char);
+}
+export function getPrefixRungs(char) {
+    return reservedRegistry.get(char);
+}
+export function hasInlineSyntax() {
+    return unreservedRegistry.size > 0;
+}
+/** Read once per scan, so an empty set leaves `needsScan` at its pre-plugin cost. */
+export function hasScanProbeRungs() {
+    return scanProbeTriggers.size > 0;
+}
+export function isScanProbeTrigger(char) {
+    return scanProbeTriggers.has(char);
+}
+/** False costs the scan loop nothing. */
+export function hasPrefixRungs() {
+    return reservedRegistry.size > 0;
+}
+export function __resetInlineSyntaxForTests() {
+    reservedRegistry.clear();
+    unreservedRegistry.clear();
+    scanProbeTriggers.clear();
+}

package/dist/core/inline/scan/scan-state.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Scanner working state, one ScanContext per scanInline call. Handlers append what they match
+ * and advance `pos`; unclaimed bytes accumulate as the pending run [textStart, pos), flushed
+ * before each appended node, so nodes + pending run cover [start, pos) at every step.
+ */
+import type { InlineNode } from '../../nodes';
+import type { BacktickRunIndex } from '../backticks';
+import type { LinkReferenceResolver } from '../link-reference-resolver';
+export interface ScanContext {
+    raw: string;
+    pos: number;
+    end: number;
+    /** Working list, flat, offset-ordered; emphasis wraps later. */
+    nodes: InlineNode[];
+    textStart: number;
+    delimiters: Delimiter[];
+    brackets: Bracket[];
+    resolver?: LinkReferenceResolver;
+    /** Built on the first code-span probe and reused by later openers, so a flood stays linear. */
+    backtickRuns?: BacktickRunIndex;
+}
+export interface Delimiter {
+    /** Held by identity: processEmphasis reorders `nodes`, so a position would go stale. */
+    node: InlineNode;
+    char: '*' | '_' | '~';
+    /** Remaining unconsumed run length. */
+    length: number;
+    /** Original run length (the multiple-of-3 rule reads this). */
+    origLength: number;
+    canOpen: boolean;
+    canClose: boolean;
+}
+export interface Bracket {
+    /** Stays valid across processEmphasis: a floor-f call only wraps nodes appended after it. */
+    nodeIndex: number;
+    isImage: boolean;
+    /** Deactivated by the links-in-links rule. */
+    active: boolean;
+    /** A collapsed/shortcut label cannot hold an unescaped bracket, so `]` skips its lookup. */
+    bracketAfter: boolean;
+    /** delimiters.length at push; processEmphasis truncates back to it on match. */
+    delimiterFloor: number;
+}
+export declare function createScanContext(raw: string, start: number, end: number, resolver?: LinkReferenceResolver): ScanContext;
+export declare function flushPendingText(ctx: ScanContext, upTo: number): void;
+export declare function appendNode(ctx: ScanContext, node: InlineNode): void;
+export declare function mergeAdjacentText(nodes: InlineNode[]): InlineNode[];

package/dist/core/inline/scan/scan-state.js

@@ -0,0 +1,48 @@
+/**
+ * Scanner working state, one ScanContext per scanInline call. Handlers append what they match
+ * and advance `pos`; unclaimed bytes accumulate as the pending run [textStart, pos), flushed
+ * before each appended node, so nodes + pending run cover [start, pos) at every step.
+ */
+export function createScanContext(raw, start, end, resolver) {
+    return {
+        raw,
+        pos: start,
+        end,
+        nodes: [],
+        textStart: start,
+        delimiters: [],
+        brackets: [],
+        resolver
+    };
+}
+export function flushPendingText(ctx, upTo) {
+    if (ctx.textStart >= upTo)
+        return;
+    ctx.nodes.push({
+        kind: 'text',
+        start: ctx.textStart,
+        end: upTo,
+        text: ctx.raw.slice(ctx.textStart, upTo)
+    });
+    ctx.textStart = upTo;
+}
+export function appendNode(ctx, node) {
+    flushPendingText(ctx, node.start);
+    ctx.nodes.push(node);
+    ctx.pos = node.end;
+    ctx.textStart = node.end;
+}
+export function mergeAdjacentText(nodes) {
+    const result = [];
+    for (const node of nodes) {
+        const prev = result[result.length - 1];
+        if (node.kind === 'text' && prev?.kind === 'text' && prev.end === node.start) {
+            prev.end = node.end;
+            prev.text = (prev.text ?? '') + (node.text ?? '');
+        }
+        else {
+            result.push(node);
+        }
+    }
+    return result;
+}

package/dist/core/inline/scan/simple-nodes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Single-construct handlers: backslash (escape / hard break), ampersand
+ * (character reference), newline (trailing-spaces hard break). Each either
+ * appends its node or leaves the dispatch character to the pending text run.
+ */
+import { type ScanContext } from './scan-state';
+export declare function handleBackslash(ctx: ScanContext): void;
+export declare function handleAmpersand(ctx: ScanContext): void;
+/**
+ * §6.7 trailing-spaces form: two-plus spaces before the newline become a hardLineBreak covering
+ * spaces + newline; one space is a softbreak. Lookback is clamped to the pending text run, so
+ * spaces inside an already-consumed node cannot count.
+ */
+export declare function handleNewline(ctx: ScanContext): void;

package/dist/core/inline/scan/simple-nodes.js

@@ -0,0 +1,53 @@
+/**
+ * Single-construct handlers: backslash (escape / hard break), ampersand
+ * (character reference), newline (trailing-spaces hard break). Each either
+ * appends its node or leaves the dispatch character to the pending text run.
+ */
+import { matchCharacterReference } from '../character-refs';
+import { ESCAPABLE_PUNCTUATION } from '../../escapable';
+import { appendNode } from './scan-state';
+export function handleBackslash(ctx) {
+    const { raw, pos, end } = ctx;
+    if (pos + 1 < end && raw[pos + 1] === '\n') {
+        appendNode(ctx, { kind: 'hardLineBreak', start: pos, end: pos + 2 });
+        return;
+    }
+    if (pos + 2 < end && raw[pos + 1] === '\r' && raw[pos + 2] === '\n') {
+        appendNode(ctx, { kind: 'hardLineBreak', start: pos, end: pos + 3 });
+        return;
+    }
+    if (pos + 1 < end && ESCAPABLE_PUNCTUATION.has(raw[pos + 1])) {
+        appendNode(ctx, { kind: 'escape', start: pos, end: pos + 2 });
+        return;
+    }
+    ctx.pos++;
+}
+export function handleAmpersand(ctx) {
+    const ref = matchCharacterReference(ctx.raw, ctx.pos, ctx.end);
+    if (ref !== null)
+        appendNode(ctx, ref);
+    else
+        ctx.pos++;
+}
+/**
+ * §6.7 trailing-spaces form: two-plus spaces before the newline become a hardLineBreak covering
+ * spaces + newline; one space is a softbreak. Lookback is clamped to the pending text run, so
+ * spaces inside an already-consumed node cannot count.
+ */
+export function handleNewline(ctx) {
+    const { raw, pos, textStart } = ctx;
+    let i = pos - 1;
+    if (i >= textStart && raw[i] === '\r')
+        i--;
+    let spaces = 0;
+    while (i >= textStart && raw[i] === ' ') {
+        spaces++;
+        i--;
+    }
+    if (spaces >= 2) {
+        appendNode(ctx, { kind: 'hardLineBreak', start: i + 1, end: pos + 1 });
+    }
+    else {
+        ctx.pos++;
+    }
+}

package/dist/core/inline/scan/url.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Spec destination/title processing: the reference's unescapeString + normalizeURI pair, over
+ * link destinations and autolink targets. Never serialized, so offsets stay lossless.
+ */
+export declare function processDestination(rawDest: string): string;
+/** The reference's unescapeString: backslash escapes resolved, entities decoded. */
+export declare function unescapeSpecString(s: string): string;
+/**
+ * mdurl-style percent-encoding: keeps valid `%XX`, encodes other ASCII outside the kept set with
+ * uppercase hex, UTF-8 percent-encodes the rest; a lone surrogate becomes the replacement char.
+ */
+export declare function percentEncodeUri(s: string): string;

package/dist/core/inline/scan/url.js

@@ -0,0 +1,82 @@
+/**
+ * Spec destination/title processing: the reference's unescapeString + normalizeURI pair, over
+ * link destinations and autolink targets. Never serialized, so offsets stay lossless.
+ */
+import { matchCharacterReference } from '../character-refs';
+import { ESCAPABLE_PUNCTUATION } from '../../escapable';
+export function processDestination(rawDest) {
+    return percentEncodeUri(unescapeSpecString(rawDest));
+}
+/** The reference's unescapeString: backslash escapes resolved, entities decoded. */
+export function unescapeSpecString(s) {
+    let out = '';
+    let i = 0;
+    while (i < s.length) {
+        const ch = s[i];
+        if (ch === '\\' && i + 1 < s.length && ESCAPABLE_PUNCTUATION.has(s[i + 1])) {
+            out += s[i + 1];
+            i += 2;
+            continue;
+        }
+        if (ch === '&') {
+            const ref = matchCharacterReference(s, i, s.length);
+            if (ref !== null && ref.decoded !== undefined) {
+                out += ref.decoded;
+                i = ref.end;
+                continue;
+            }
+        }
+        out += ch;
+        i++;
+    }
+    return out;
+}
+// The mdurl encode() kept set: commonmark.js normalizes destinations through it, so the
+// differ needs byte-equal output.
+const URI_SAFE = buildUriSafeTable(";/?:@&=+$,-_.!~*'()#");
+function buildUriSafeTable(kept) {
+    const safe = new Array(128).fill(false);
+    for (let code = 0x30; code <= 0x39; code++)
+        safe[code] = true;
+    for (let code = 0x41; code <= 0x5a; code++)
+        safe[code] = true;
+    for (let code = 0x61; code <= 0x7a; code++)
+        safe[code] = true;
+    for (const ch of kept)
+        safe[ch.charCodeAt(0)] = true;
+    return safe;
+}
+const HEX_PAIR = /^[0-9a-f]{2}$/i;
+/**
+ * mdurl-style percent-encoding: keeps valid `%XX`, encodes other ASCII outside the kept set with
+ * uppercase hex, UTF-8 percent-encodes the rest; a lone surrogate becomes the replacement char.
+ */
+export function percentEncodeUri(s) {
+    let out = '';
+    for (let i = 0; i < s.length; i++) {
+        const code = s.charCodeAt(i);
+        if (code === 0x25 && i + 2 < s.length && HEX_PAIR.test(s.slice(i + 1, i + 3))) {
+            out += s.slice(i, i + 3);
+            i += 2;
+            continue;
+        }
+        if (code < 128) {
+            out += URI_SAFE[code] ? s[i] : '%' + code.toString(16).toUpperCase().padStart(2, '0');
+            continue;
+        }
+        if (code >= 0xd800 && code <= 0xdfff) {
+            if (code <= 0xdbff && i + 1 < s.length) {
+                const next = s.charCodeAt(i + 1);
+                if (next >= 0xdc00 && next <= 0xdfff) {
+                    out += encodeURIComponent(s[i] + s[i + 1]);
+                    i++;
+                    continue;
+                }
+            }
+            out += '%EF%BF%BD';
+            continue;
+        }
+        out += encodeURIComponent(s[i]);
+    }
+    return out;
+}

package/dist/core/inline/transparency.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The single implementation of the vertical-skip decision: does a block carry no column meaning,
+ * so cross-block vertical traversal should pass over it? Reads the inline tree on demand, so it
+ * answers for an off-window leaf with no component. An empty result reads as not-transparent, so
+ * an unparsed block degrades to "land on it".
+ */
+import type { NodeView } from '../node-views';
+export declare function isVerticallyTransparentNode(node: NodeView | null | undefined): boolean;

package/dist/core/inline/transparency.js

@@ -0,0 +1,39 @@
+/**
+ * The single implementation of the vertical-skip decision: does a block carry no column meaning,
+ * so cross-block vertical traversal should pass over it? Reads the inline tree on demand, so it
+ * answers for an off-window leaf with no component. An empty result reads as not-transparent, so
+ * an unparsed block degrades to "land on it".
+ */
+import { getInlineContent } from './inline-cache';
+import { isInlineWidget, getInlineWidgetEditing } from './inline-widgets';
+export function isVerticallyTransparentNode(node) {
+    if (!node)
+        return false;
+    // A cell is a grid-column landing and renders images as alt text, so without this gate the
+    // recursion below would skip an image-only cell (VR-6).
+    if (node.kind === 'table' || node.kind === 'tableRow' || node.kind === 'tableCell')
+        return false;
+    if (node.children) {
+        // An empty container carries a caret position; `[].every()` is true and would skip it.
+        if (node.children.length === 0)
+            return false;
+        return node.children.every(isVerticallyTransparentNode);
+    }
+    // No resolver, so the path-walkers that call this carry none either. The cost is that a
+    // reference-style-image-only paragraph reads as opaque; direct `![](url)` is unaffected.
+    const inlines = getInlineContent(node);
+    if (inlines.length === 0)
+        return false;
+    for (const inline of inlines) {
+        if (isInlineWidget(inline, node.raw)) {
+            // A step-over widget is character-like: it carries a column, so it reads as text.
+            if (getInlineWidgetEditing(inline.kind)?.onEdge === 'step-over')
+                return false;
+            continue;
+        }
+        if (inline.kind === 'text' && (inline.text ?? '').trim() === '')
+            continue;
+        return false;
+    }
+    return true;
+}

package/dist/core/inline/visibility.d.ts

@@ -0,0 +1,81 @@
+/**
+ * What a marker-hiding mode leaves on screen. `inline-render.ts` decides which bytes become which
+ * span; this decides which of those spans the reader sees, and it is the one home for that rule:
+ * the DOM walk (`cursor/widget-offset.ts`) is its other consumer, in the space that has a caret.
+ * The two answers are held together by `test/invariants/screen-truth.property.test.ts`, not by
+ * convention. Context vocabulary: `docs/design/live-mode.md` § 2.
+ */
+import type { InlineNode } from '../nodes';
+import { type RenderInlineOptions } from '../inline-render';
+import { type PresentationMode } from '../../presentation-mode';
+/** The span families a marker-hiding mode drops. `fence-line` is a block's own chrome, minted
+ *  outside this file, and is named here because the hiding rule is one rule. */
+export type MarkerFamily = 'marker' | 'fence-line' | 'ref-label';
+/** Every family at once, for a caller reading spans back out of a rendered fragment. */
+export declare const MARKER_FAMILY_SELECTOR: string;
+/**
+ * The family `el` belongs to, or null for anything else. A `contenteditable="false"` marker is
+ * the ambient prefix island, which keeps its box in every mode (`ambient/ambient-cursor.ts`), so
+ * it belongs to no family.
+ */
+export declare function markerFamilyOf(el: Element): MarkerFamily | null;
+/** Whether the content-empty override paints `family` (`styles/editor.css`, same scoping). A
+ *  reference label is resolution metadata rather than chrome a caret types against, so it stays
+ *  hidden, and a container holding only labels has no paint to promise. */
+export declare function familyPaintsAlone(family: MarkerFamily): boolean;
+/** What a container does to the marker spans rendered into it. Minted only by the two readings
+ *  below, so a call site states which question it is asking rather than two loose booleans. */
+export interface VisibilityContext {
+    /** Whether marker spans drop at all — false in source mode, where every byte is on screen. */
+    readonly hidesMarkers: boolean;
+    /** Whether the container's chrome stands over no content and therefore paints anyway. */
+    readonly chromePaints: boolean;
+}
+/**
+ * What the reader sees on a container painting under `mode`. `chromePaints` is that container's
+ * own stamp condition (live-mode.md § 4.1), which reading declines: it takes no keystrokes, so a
+ * construct with nothing behind its chrome may paint nothing there. The preview rungs' per-span
+ * reveal is DOM state and stays with the walk; this answers for an unrevealed container.
+ */
+export declare function screenVisibility(mode: PresentationMode, container: {
+    chromePaints: boolean;
+}): VisibilityContext;
+/**
+ * The content behind every marker family, whatever the container paints: the reading a rewrite's
+ * before/after conservation diff needs, since chrome folds the moment content arrives and a diff
+ * against the screen would read that fold as bytes lost. Sound only past a
+ * {@link paintsOnlyChrome} gate — over chrome the reader IS looking at, this reading calls those
+ * bytes unseen and licenses dropping them.
+ */
+export declare const CONTENT_VISIBILITY: VisibilityContext;
+/** Whether a `family` span paints NOTHING under `ctx` — the one hiding rule, before any preview
+ *  reveal. */
+export declare function familyHidesText(family: MarkerFamily, ctx: VisibilityContext): boolean;
+/**
+ * One stretch of `raw` as the reader meets it. `text` is what it paints, which is not always
+ * `raw.slice(start, end)`: an atomic widget substitutes its own.
+ */
+export interface VisibleRun {
+    start: number;
+    end: number;
+    text: string;
+    visible: boolean;
+}
+/**
+ * `nodes` as runs of raw bytes, each carrying what it paints under `ctx`. Read off the rendered
+ * DOM rather than derived per kind, because which bytes a construct shows only the painter
+ * answers (G4.33): a caller re-deriving that drifts from what paints, which is the only thing the
+ * answer is worth anything as. Top-level nodes render one at a time, so a CLIPPED list (a join
+ * seam's surviving side) keeps honest offsets instead of a running count that assumes contiguity.
+ */
+export declare function visibleRuns(nodes: readonly InlineNode[], raw: string, ctx: VisibilityContext, opts?: RenderInlineOptions): VisibleRun[];
+/** The text a reader SEES for `nodes` — every run `ctx` leaves on screen, in source order. */
+export declare function renderedText(nodes: readonly InlineNode[], raw: string, ctx: VisibilityContext, opts?: RenderInlineOptions): string;
+/**
+ * Whether `nodes` are chrome standing over nothing, and therefore ALL on screen (live-mode.md
+ * § 4.1). The inline half of the content-empty stamp, for a seam with no DOM to read the stamp
+ * off: a license over bytes the reader never saw has nothing to claim here. A block's OWN chrome
+ * (a `## ` prefix, a fence line) sits outside the inline content range, so an empty one answers
+ * false and the surfaces that own it are unaffected.
+ */
+export declare function paintsOnlyChrome(nodes: readonly InlineNode[], raw: string, opts?: RenderInlineOptions): boolean;