@voithos-labs/aragonite 0.10.4 → 0.10.7

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

@@ -0,0 +1,26 @@
+/**
+ * The characters the inline scanner handles itself, one row each: the handler it runs and when
+ * the fast bail (`needsScan`, ./index.ts) looks for the character. The fast bail and the plugin
+ * registry's reserved triggers (./plugin-syntax.ts) derive from this table, and a test holds the
+ * scanner's switch to its rows.
+ */
+import { handleAngle } from './autolinks';
+import { handleBang, handleCloseBracket, handleOpenBracket } from './brackets';
+import { handleBacktick } from './code-spans';
+import { handleDelimiter } from './emphasis';
+import { handleAmpersand, handleBackslash, handleNewline } from './simple-nodes';
+export const BUILTIN_TRIGGERS = new Map([
+    ['\\', { handler: handleBackslash, scanned: 'always' }],
+    ['`', { handler: handleBacktick, scanned: 'always' }],
+    ['&', { handler: handleAmpersand, scanned: 'always' }],
+    ['\n', { handler: handleNewline, scanned: 'always' }],
+    ['*', { handler: handleDelimiter, scanned: 'always' }],
+    ['_', { handler: handleDelimiter, scanned: 'always' }],
+    ['~', { handler: handleDelimiter, scanned: 'always' }],
+    ['[', { handler: handleOpenBracket, scanned: 'always' }],
+    // `!` and `]` matter to the built-in scan only in a range holding a `[`, so prose such as
+    // "Hello!" skips the scan loop.
+    ['!', { handler: handleBang, scanned: 'when-registered' }],
+    [']', { handler: handleCloseBracket, scanned: 'never' }],
+    ['<', { handler: handleAngle, scanned: 'always' }]
+]);

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

@@ -4,6 +4,7 @@
  */
 import { matchCharacterReference } from '../character-refs';
 import { ESCAPABLE_PUNCTUATION } from '../../escapable';
+import { isHighSurrogate, isLowSurrogate } from '../../lines';
 export function processDestination(rawDest) {
     return percentEncodeUri(unescapeSpecString(rawDest));
 }
@@ -31,8 +32,8 @@ export function unescapeSpecString(s) {
     }
     return out;
 }
-// The mdurl encode() kept set: commonmark.js normalizes destinations through it, so the
-// differ needs byte-equal output.
+// mdurl encode()'s kept set, which commonmark.js normalizes destinations through, so a url
+// here matches the reference byte for byte.
 const URI_SAFE = buildUriSafeTable(";/?:@&=+$,-_.!~*'()#");
 function buildUriSafeTable(kept) {
     const safe = new Array(128).fill(false);
@@ -64,14 +65,11 @@ export function percentEncodeUri(s) {
             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;
-                }
+        if (isHighSurrogate(code) || isLowSurrogate(code)) {
+            if (isHighSurrogate(code) && isLowSurrogate(s.charCodeAt(i + 1))) {
+                out += encodeURIComponent(s[i] + s[i + 1]);
+                i++;
+                continue;
             }
             out += '%EF%BF%BD';
             continue;

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

@@ -5,4 +5,5 @@
  * an unparsed block degrades to "land on it".
  */
 import type { NodeView } from '../node-views';
-export declare function isVerticallyTransparentNode(node: NodeView | null | undefined): boolean;
+import type { GrammarView } from '../../schema/block-openers';
+export declare function isVerticallyTransparentNode(node: NodeView | null | undefined, grammar: GrammarView): boolean;

package/dist/core/inline/transparency.js

@@ -4,34 +4,50 @@
  * 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 { isBlankText } from '../lines';
 import { getInlineContent } from './inline-cache';
 import { isInlineWidget, isCharacterLikeWidget } from './inline-widgets';
-export function isVerticallyTransparentNode(node) {
+import { isGridKind, tryGetBlockKindDescriptor } from '../../schema/block-kind-descriptor';
+export function isVerticallyTransparentNode(node, grammar) {
     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)
+    // An explicit stack: container depth is input-controlled, so recursion could overflow.
+    const pending = [node];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        // Every grid cell is a caret stop and draws its images as alt text, so vertical caret
+        // movement must stop in an image-only cell rather than pass over it.
+        if (isGridKind(current.kind))
+            return false;
+        if (tryGetBlockKindDescriptor(current.kind)?.renderImagesAsWidgets === false)
+            return false;
+        if (current.children) {
+            // An empty container carries a caret position.
+            if (current.children.length === 0)
+                return false;
+            for (const child of current.children)
+                pending.push(child);
+        }
+        else if (!isTransparentLeaf(current, grammar)) {
             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);
+    return true;
+}
+function isTransparentLeaf(node, grammar) {
+    // No resolver, since the path-walking callers hold none: a paragraph of only reference-style
+    // images reads as opaque, while a direct `![](url)` is unaffected.
+    const inlines = getInlineContent(node, undefined, '', grammar);
     if (inlines.length === 0)
         return false;
     for (const inline of inlines) {
-        if (isInlineWidget(inline, node.raw)) {
+        if (isInlineWidget(inline, node.raw, grammar)) {
             // A character-like widget carries a column, so it reads as text.
-            if (isCharacterLikeWidget(inline.kind))
+            if (isCharacterLikeWidget(inline.kind, grammar))
                 return false;
             continue;
         }
-        if (inline.kind === 'text' && (inline.text ?? '').trim() === '')
+        if (inline.kind === 'text' && isBlankText(inline.text ?? ''))
             continue;
         return false;
     }

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

@@ -1,59 +1,50 @@
 /**
  * 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.
+ * span; this file decides which of those spans the user sees, and it is the one place that rule
+ * lives: the DOM traversal (`cursor/widget-offset.ts`) reads it too, and a property test
+ * (`screen-truth.property.test.ts`) holds the two answers together. Terms: `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. */
+/** The span families a marker-hiding mode drops. `fence-line` spans are a block's own fence lines,
+ *  created outside this file, and are 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.
+ * Whether `el` is a container's leading marker prefix (`> `, `- `): the read-only marker span a
+ * container draws before its first child's text, which keeps its box in every mode.
  */
+export declare function isMarkerPrefixSpan(el: Element): boolean;
+/** The family `el` belongs to, or null for anything else. A marker prefix span belongs to none,
+ *  since no mode hides it. */
 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. */
+/** Whether the content-empty override in `styles/editor.css` shows `family`. A reference label
+ *  is lookup metadata, not a marker the caret types against, so it stays hidden. */
 export declare function familyPaintsAlone(family: MarkerFamily): boolean;
-/** What a container does to the marker spans rendered into it. Minted only by the two readings
+/** What a container does to the marker spans rendered into it. Built 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. */
+    /** 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. */
+    /** Whether the container's markers stand over no content and therefore stay visible. */
     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.
- */
+/** Reading mode ignores the content-empty condition (live-mode.md § 4.1), since it takes no
+ *  keystrokes. Answers for an unrevealed container: a preview's per-span reveal is DOM state. */
 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.
- */
+/** The content behind every marker family, for a rewrite's before/after comparison. Sound only
+ *  behind a {@link paintsOnlyChrome} check, or it lets visible markers drop (live-mode.md § 2). */
 export declare const CONTENT_VISIBILITY: VisibilityContext;
-/** Whether a `family` span paints NOTHING under `ctx` — the one hiding rule, before any preview
+/** Whether a `family` span shows 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.
+ * One stretch of `raw` as the user sees it. `text` is what it shows, which is not always
+ * `raw.slice(start, end)`: a widget substitutes its own.
  */
 export interface VisibleRun {
     start: number;
@@ -61,21 +52,11 @@ export interface VisibleRun {
     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;
+/** Read off the rendered DOM, since only the renderer knows which bytes a construct shows
+ *  (G4.33). Each top-level node renders alone, so a clipped list keeps its offsets. */
+export declare function visibleRuns(nodes: readonly InlineNode[], raw: string, ctx: VisibilityContext, opts: RenderInlineOptions): VisibleRun[];
+/** The text the user 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 markers over no content, which stay on screen (live-mode.md § 4.1). A
+ *  block's own markers (`## `, a fence) sit outside the inline range: an empty block is false. */
+export declare function paintsOnlyChrome(nodes: readonly InlineNode[], raw: string, opts: RenderInlineOptions): boolean;

package/dist/core/inline/visibility.js

@@ -1,9 +1,8 @@
 /**
  * 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.
+ * span; this file decides which of those spans the user sees, and it is the one place that rule
+ * lives: the DOM traversal (`cursor/widget-offset.ts`) reads it too, and a property test
+ * (`screen-truth.property.test.ts`) holds the two answers together. Terms: `live-mode.md` § 2.
  */
 import { renderInlineNodes } from '../inline-render';
 import { widgetSourceRange } from './inline-widgets';
@@ -18,33 +17,31 @@ export const MARKER_FAMILY_SELECTOR = Object.values(FAMILY_CLASS)
     .map((cls) => `.${cls}`)
     .join(', ');
 /**
- * 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.
+ * Whether `el` is a container's leading marker prefix (`> `, `- `): the read-only marker span a
+ * container draws before its first child's text, which keeps its box in every mode.
  */
+export function isMarkerPrefixSpan(el) {
+    return (el.classList.contains(FAMILY_CLASS.marker) && el.getAttribute('contenteditable') === 'false');
+}
+/** The family `el` belongs to, or null for anything else. A marker prefix span belongs to none,
+ *  since no mode hides it. */
 export function markerFamilyOf(el) {
     const classes = el.classList;
-    if (classes.contains(FAMILY_CLASS.marker)) {
-        return el.getAttribute('contenteditable') === 'false' ? null : 'marker';
-    }
+    if (classes.contains(FAMILY_CLASS.marker))
+        return isMarkerPrefixSpan(el) ? null : 'marker';
     if (classes.contains(FAMILY_CLASS['fence-line']))
         return 'fence-line';
     if (classes.contains(FAMILY_CLASS['ref-label']))
         return 'ref-label';
     return 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. */
+/** Whether the content-empty override in `styles/editor.css` shows `family`. A reference label
+ *  is lookup metadata, not a marker the caret types against, so it stays hidden. */
 export function familyPaintsAlone(family) {
     return family !== 'ref-label';
 }
-/**
- * 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.
- */
+/** Reading mode ignores the content-empty condition (live-mode.md § 4.1), since it takes no
+ *  keystrokes. Answers for an unrevealed container: a preview's per-span reveal is DOM state. */
 export function screenVisibility(mode, container) {
     switch (mode) {
         case 'source':
@@ -61,58 +58,43 @@ export function screenVisibility(mode, container) {
         }
     }
 }
-/**
- * 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.
- */
+/** The content behind every marker family, for a rewrite's before/after comparison. Sound only
+ *  behind a {@link paintsOnlyChrome} check, or it lets visible markers drop (live-mode.md § 2). */
 export const CONTENT_VISIBILITY = { hidesMarkers: true, chromePaints: false };
-/** A container whose chrome stands over no content: every family the override paints does. */
+/** A container whose markers stand over no content: every family the override shows is visible. */
 const CHROME_STANDS_ALONE = { hidesMarkers: true, chromePaints: true };
-/** Whether a `family` span paints NOTHING under `ctx` — the one hiding rule, before any preview
+/** Whether a `family` span shows nothing under `ctx`: the one hiding rule, before any preview
  *  reveal. */
 export function familyHidesText(family, ctx) {
     return ctx.hidesMarkers && !(ctx.chromePaints && familyPaintsAlone(family));
 }
-/**
- * `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 function visibleRuns(nodes, raw, ctx, opts = {}) {
+/** Read off the rendered DOM, since only the renderer knows which bytes a construct shows
+ *  (G4.33). Each top-level node renders alone, so a clipped list keeps its offsets. */
+export function visibleRuns(nodes, raw, ctx, opts) {
     const runs = [];
     for (const node of nodes) {
         collectRuns(renderInlineNodes([node], raw, opts), node.start, ctx, runs);
     }
     return runs;
 }
-/** The text a reader SEES for `nodes` — every run `ctx` leaves on screen, in source order. */
-export function renderedText(nodes, raw, ctx, opts = {}) {
+/** The text the user sees for `nodes`: every run `ctx` leaves on screen, in source order. */
+export function renderedText(nodes, raw, ctx, opts) {
     let out = '';
     for (const run of visibleRuns(nodes, raw, ctx, opts))
         if (run.visible)
             out += run.text;
     return out;
 }
-/**
- * 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 function paintsOnlyChrome(nodes, raw, opts = {}) {
+/** Whether `nodes` are markers over no content, which stay on screen (live-mode.md § 4.1). A
+ *  block's own markers (`## `, a fence) sit outside the inline range: an empty block is false. */
+export function paintsOnlyChrome(nodes, raw, opts) {
     return (renderedText(nodes, raw, CONTENT_VISIBILITY, opts) === '' &&
         renderedText(nodes, raw, CHROME_STANDS_ALONE, opts) !== '');
 }
 function collectRuns(fragment, start, ctx, out) {
     let at = start;
     const stack = [];
-    // Reversed push, so pop order is source order — which `at` advances along.
+    // Reversed push, so pop order is source order, which `at` advances along.
     const pushChildren = (parent, hidden) => {
         const children = parent.childNodes;
         for (let i = children.length - 1; i >= 0; i--)
@@ -130,8 +112,8 @@ function collectRuns(fragment, start, ctx, out) {
         if (dom.nodeType !== Node.ELEMENT_NODE)
             continue;
         const el = dom;
-        // Only an atomic widget's shell carries a source range here, and it is the one element
-        // whose text is not its bytes — so the range is both the test and the re-sync.
+        // Only a widget's shell carries a source range here, and it is the one element whose text
+        // is not its bytes, so the range is both the test and the re-sync.
         const source = widgetSourceRange(el);
         if (source !== null) {
             out.push({ ...source, text: el.textContent ?? '', visible: !hidden });

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

@@ -1,14 +1,8 @@
 /**
- * The one iterative pre-order over an inline tree. Nesting depth is input-controlled (a `**` run
- * nests one construct per pair), so a per-level call frame overflows the stack and strands the
- * block in the unhealable failed-block fallback. Dependency-free, so the scan reaches it without
- * closing a cycle through the inline entry point.
+ * The one iterative pre-order over an inline tree: nesting depth is input-controlled, so a
+ * recursive walk could overflow the stack.
  */
 import type { InlineNode } from '../nodes';
-/**
- * Each node, then its children, in source order. `descend` declines a node's children — the node
- * itself is still yielded, and is asked only when it has any. Yields nodes only: what a reader
- * SEES stays the render path's question (G4.33). Each child list is snapshotted onto the stack
- * when its parent pops, so a consumer that rewrites `children` must finish the walk first.
- */
+/** `descend` returning false skips a node's children but still yields the node. Finish the walk
+ *  before rewriting any `children`: a child list is read only after its parent is yielded. */
 export declare function inlineDescendants(nodes: readonly InlineNode[], descend?: (node: InlineNode) => boolean): Generator<InlineNode>;

package/dist/core/inline/walk.js

@@ -1,15 +1,9 @@
 /**
- * The one iterative pre-order over an inline tree. Nesting depth is input-controlled (a `**` run
- * nests one construct per pair), so a per-level call frame overflows the stack and strands the
- * block in the unhealable failed-block fallback. Dependency-free, so the scan reaches it without
- * closing a cycle through the inline entry point.
- */
-/**
- * Each node, then its children, in source order. `descend` declines a node's children — the node
- * itself is still yielded, and is asked only when it has any. Yields nodes only: what a reader
- * SEES stays the render path's question (G4.33). Each child list is snapshotted onto the stack
- * when its parent pops, so a consumer that rewrites `children` must finish the walk first.
+ * The one iterative pre-order over an inline tree: nesting depth is input-controlled, so a
+ * recursive walk could overflow the stack.
  */
+/** `descend` returning false skips a node's children but still yields the node. Finish the walk
+ *  before rewriting any `children`: a child list is read only after its parent is yielded. */
 export function* inlineDescendants(nodes, descend) {
     // Reversed push, so pop order is source order.
     const stack = [];

package/dist/core/inline-render.d.ts

@@ -1,12 +1,12 @@
 /**
- * DOM renderer for InlineNode trees. Over a widget-free range the fragment's textContent equals
- * raw.slice. Atomic widgets break that by design, contributing their own text or none and
- * carrying source bytes on `data-source-*`, so a raw offset is recovered only through the shared
- * walk (cursor/widget-offset.ts), never by counting textContent. Stated both ways by G2.4.
- *
- * Which of the spans minted here a mode leaves on screen is `inline/visibility.ts`.
+ * DOM renderer for inline node trees. Over a widget-free range the fragment's textContent equals
+ * raw.slice. Widgets break that by design, contributing their own text or none and carrying their
+ * source bytes on `data-source-*`, so a raw offset is recovered only through the shared DOM
+ * traversal (cursor/widget-offset.ts), never by counting textContent (G2.4). Which of the spans
+ * built here a mode leaves on screen is `inline/visibility.ts`.
  */
 import type { InlineNode } from './nodes';
+import type { GrammarView } from '../schema/block-openers';
 export type ImageLoadPolicy = 'auto' | 'placeholder';
 export interface RenderInlineOptions {
     renderImagesAsWidgets?: boolean;
@@ -21,34 +21,29 @@ export interface RenderInlineOptions {
         imageLoadPolicy: ImageLoadPolicy;
     }) => Node;
     /**
-     * Mounts a `component`-kind widget in the atomic-island wrapper. Injected for the same reason
+     * Mounts a `component`-kind widget in the widget shell wrapper. Injected for the same reason
      * as `buildImageWidget`; absent or null falls the widget back to its raw source.
      */
     buildPortalWidget?: (node: InlineNode, raw: string) => HTMLElement | null;
-    /**
-     * Paint a lone backslash ending the display as the hard break it is about to become: the
-     * byte as a (hidden) marker plus two `br` anchors so the caret has a second line to sit on.
-     * Only for a mode that hides markers; the DOM stays byte-identical elsewhere.
-     */
-    pendingBreakSeat?: boolean;
-    /**
-     * Stamp marker spans with the construct's raw range, so preview-inline's reveal trigger can
-     * address them. Attributes only, leaving textContent and the offset walk untouched. Off by
-     * default so the DOM stays byte-identical outside preview-inline.
-     */
+    /** The editor's grammar: a widget kind whose plugin it leaves out renders as its source. */
+    grammar: GrammarView;
+    /** The block's content end, where a lone backslash is a pending hard break, drawn as a hidden
+     *  marker plus two `br` anchors. Only for a mode that hides markers. */
+    pendingBreakAt?: number;
+    /** Write each construct's raw range onto its marker spans as data attributes, for the
+     *  preview-inline reveal. Off by default, so the DOM stays byte-identical elsewhere. */
     tagConstructMarkers?: boolean;
 }
-/** The one href funnel for every sink — a consumer's rewrite, then the scheme allowlist; undefined
- *  reads as "render inert". Exported: the link card's Open button hands over a user-typed URL. */
-export declare function resolveHref(opts: RenderInlineOptions, url: string | undefined): string | undefined;
-export declare function renderInlineNodes(nodes: InlineNode[], raw: string, opts?: RenderInlineOptions): DocumentFragment;
+/** The one href path every DOM sink goes through: a consumer's rewrite, then the scheme allowlist.
+ *  Undefined means render inert. */
+export declare function resolveHref(opts: Pick<RenderInlineOptions, 'resolveLinkUrl'>, url: string | undefined): string | undefined;
+export declare function renderInlineNodes(nodes: InlineNode[], raw: string, opts: RenderInlineOptions): DocumentFragment;
+/** The first of a pending hard break's two anchors, where the new line starts. */
+export declare const PENDING_BREAK_ANCHOR = "br[data-caret-anchor=\"break\"]";
 export interface OffsetResult {
     node: InlineNode;
     localOffset: number;
 }
-/**
- * The leaf containing `offset`, preferring the right node at a boundary; `offset === end` only
- * matches the last node. Model-layer, touching no DOM: the DOM counterpart is
- * `findDomTextOffsetTarget` in cursor/widget-offset.ts.
- */
+/** The leaf containing `offset`, preferring the right node at a boundary; `offset === end` matches
+ *  only the last node. The DOM side is `findDomTextOffsetTarget` in `cursor/widget-offset.ts`. */
 export declare function findNodeAtOffset(nodes: InlineNode[], offset: number): OffsetResult | null;