@voithos-labs/aragonite 0.10.1

package/dist/core/inline/html-tag-grammar.d.ts

@@ -0,0 +1,16 @@
+/**
+ * CommonMark §6.6 HTML tag grammar, the one definition the inline `<` handler
+ * (scan/autolinks.ts) and the block-level type-7 catch-all (parsers/html-block.ts) share.
+ * The tag sources are exported so the block parser anchors them at line scope rather than
+ * keeping a copy that could drift.
+ */
+export type HtmlFormKind = 'openTag' | 'closeTag' | 'comment' | 'pi' | 'declaration' | 'cdata';
+/** Open tag `<name (attrs)* /?>` (CommonMark §6.6), unanchored source. */
+export declare const OPEN_TAG_SOURCE: string;
+/** Close tag `</name>` with optional whitespace before `>`, unanchored source. */
+export declare const CLOSE_TAG_SOURCE: string;
+/** `pos` must point at `<`; every branch honors the `end` bound. */
+export declare function matchHtmlFormAt(raw: string, pos: number, end: number): {
+    kind: HtmlFormKind;
+    length: number;
+} | null;

package/dist/core/inline/html-tag-grammar.js

@@ -0,0 +1,58 @@
+/**
+ * CommonMark §6.6 HTML tag grammar, the one definition the inline `<` handler
+ * (scan/autolinks.ts) and the block-level type-7 catch-all (parsers/html-block.ts) share.
+ * The tag sources are exported so the block parser anchors them at line scope rather than
+ * keeping a copy that could drift.
+ */
+const OPEN_TAG = /<[A-Za-z][A-Za-z0-9-]*(?:\s+[a-zA-Z_:][a-zA-Z0-9_.:-]*(?:\s*=\s*(?:[^\s"'=<>`]+|"[^"]*"|'[^']*'))?)*\s*\/?>/;
+const CLOSE_TAG = /<\/[A-Za-z][A-Za-z0-9-]*\s*>/;
+/** Open tag `<name (attrs)* /?>` (CommonMark §6.6), unanchored source. */
+export const OPEN_TAG_SOURCE = OPEN_TAG.source;
+/** Close tag `</name>` with optional whitespace before `>`, unanchored source. */
+export const CLOSE_TAG_SOURCE = CLOSE_TAG.source;
+const OPEN_TAG_AT_POS = new RegExp(`^${OPEN_TAG_SOURCE}`);
+const CLOSE_TAG_AT_POS = new RegExp(`^${CLOSE_TAG_SOURCE}`);
+/** `pos` must point at `<`; every branch honors the `end` bound. */
+export function matchHtmlFormAt(raw, pos, end) {
+    if (pos >= end || raw[pos] !== '<' || pos + 1 >= end)
+        return null;
+    const next = raw[pos + 1];
+    if (next === '!') {
+        if (raw.startsWith('<!--', pos)) {
+            const closeAt = raw.indexOf('-->', pos + 4);
+            if (closeAt === -1 || closeAt + 3 > end)
+                return null;
+            return { kind: 'comment', length: closeAt + 3 - pos };
+        }
+        if (raw.startsWith('<![CDATA[', pos)) {
+            const closeAt = raw.indexOf(']]>', pos + 9);
+            if (closeAt === -1 || closeAt + 3 > end)
+                return null;
+            return { kind: 'cdata', length: closeAt + 3 - pos };
+        }
+        if (pos + 2 < end && /[A-Za-z]/.test(raw[pos + 2])) {
+            const closeAt = raw.indexOf('>', pos + 3);
+            if (closeAt === -1 || closeAt >= end)
+                return null;
+            return { kind: 'declaration', length: closeAt + 1 - pos };
+        }
+        return null;
+    }
+    if (next === '?') {
+        const closeAt = raw.indexOf('?>', pos + 2);
+        if (closeAt === -1 || closeAt + 2 > end)
+            return null;
+        return { kind: 'pi', length: closeAt + 2 - pos };
+    }
+    if (next === '/') {
+        const slice = raw.slice(pos, end);
+        const m = CLOSE_TAG_AT_POS.exec(slice);
+        return m ? { kind: 'closeTag', length: m[0].length } : null;
+    }
+    if (/[A-Za-z]/.test(next)) {
+        const slice = raw.slice(pos, end);
+        const m = OPEN_TAG_AT_POS.exec(slice);
+        return m ? { kind: 'openTag', length: m[0].length } : null;
+    }
+    return null;
+}

package/dist/core/inline/image-dimensions.d.ts

@@ -0,0 +1,6 @@
+export interface ParsedImageAlt {
+    displayAlt: string;
+    width: number | undefined;
+    height: number | undefined;
+}
+export declare function parseImageDimensions(alt: string): ParsedImageAlt;

package/dist/core/inline/image-dimensions.js

@@ -0,0 +1,42 @@
+// `|N` / `|NxM` is an Obsidian extension, not part of GFM.
+const MAX_DIMENSION = 10000;
+// The longest zero-free decodable suffix, `|10000x10000`. Bounding the pipe search to that tail
+// keeps nested-label floods linear, at the deliberate cost of not decoding zero-padded runs.
+const MAX_SUFFIX_SEARCH = 12;
+export function parseImageDimensions(alt) {
+    const lastPipe = boundedLastPipe(alt);
+    const dims = lastPipe === -1 ? null : parseDimensionSuffix(alt.slice(lastPipe + 1));
+    if (dims === null)
+        return { displayAlt: alt, width: undefined, height: undefined };
+    return { displayAlt: alt.slice(0, lastPipe), width: dims.width, height: dims.height };
+}
+function boundedLastPipe(alt) {
+    const floor = alt.length > MAX_SUFFIX_SEARCH ? alt.length - MAX_SUFFIX_SEARCH : 0;
+    for (let i = alt.length - 1; i >= floor; i--) {
+        if (alt[i] === '|')
+            return i;
+    }
+    return -1;
+}
+function parseDimensionSuffix(s) {
+    const xIdx = s.indexOf('x');
+    if (xIdx === -1) {
+        const w = parseStrictInt(s);
+        if (w === null)
+            return null;
+        return { width: w, height: undefined };
+    }
+    const w = parseStrictInt(s.slice(0, xIdx));
+    const h = parseStrictInt(s.slice(xIdx + 1));
+    if (w === null || h === null)
+        return null;
+    return { width: w, height: h };
+}
+function parseStrictInt(s) {
+    if (s.length === 0 || !/^\d+$/.test(s))
+        return null;
+    const n = Number(s);
+    if (n <= 0 || n > MAX_DIMENSION)
+        return null;
+    return n;
+}

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

@@ -0,0 +1,42 @@
+/** Inline parser entry. See docs/design/inline-parsing.md. */
+import type { AnyInlineKind, CstNode, InlineNode } from '../nodes';
+import type { NodeView } from '../node-views';
+import type { LinkReferenceResolver } from './link-reference-resolver';
+import { inlineDescendants } from './walk';
+export interface ContentRange {
+    start: number;
+    end: number;
+}
+declare const contentLengthBrand: unique symbol;
+/** Raw-space length of a block's rendered content, mintable only from its content range: a
+ *  DOM-measured length answers in walk space and lags the pass that is rewriting the DOM. */
+export type ContentLength = number & {
+    readonly [contentLengthBrand]: true;
+};
+/** Content range within a prose block's raw; marker-bearing kinds override via descriptor. */
+export declare function getContentRange(node: NodeView): ContentRange;
+/** The one {@link ContentLength} mint. */
+export declare function contentLengthOf(node: NodeView): ContentLength;
+export declare function isProseKind(kind: CstNode['kind']): boolean;
+/**
+ * The bytes an INLINE construct's delimiters do not cover, or null for a kind that has none — a
+ * bare text run, an escape, a pair emptied of content. The inline twin of {@link getContentRange},
+ * here rather than beside one of its callers because the caret bounds, the typing seat, the
+ * destructive arm and the toggles all need the same answer.
+ */
+export declare function constructContentRange(node: InlineNode): ContentRange | null;
+/**
+ * A prose node's inline tree, pure: no caching, no reactive reads. The render path calls this
+ * directly; the caching accessor (inline-cache.ts) calls it on a miss.
+ */
+export declare function computeInlineContent(node: NodeView, resolver?: LinkReferenceResolver): InlineNode[];
+/**
+ * Parse inline content over raw[start, end). Node offsets are absolute into raw, and every byte
+ * lands in exactly one node's range. Both bounds are checked, not just typed: a caller the
+ * compiler cannot reach that passes only the source would otherwise get one whole-string text
+ * node, which is wrong output that looks like a result.
+ */
+export declare function parseInline(raw: string, start: number, end: number, resolver?: LinkReferenceResolver): InlineNode[];
+export { inlineDescendants };
+/** Every construct kind anywhere in a parse, at any depth. */
+export declare function constructKinds(nodes: readonly InlineNode[]): Set<AnyInlineKind>;

package/dist/core/inline/index.js

@@ -0,0 +1,77 @@
+/** Inline parser entry. See docs/design/inline-parsing.md. */
+import { displayLength } from '../lines';
+import { getBlockKindDescriptor } from '../../schema/block-kind-descriptor';
+// Registered before any descriptor read, headless of the editor mount. Explicit call: a bare
+// side-effect import is tree-shaken from the production build.
+import { registerBuiltInDescriptors } from '../../schema/built-in-descriptors';
+import { scanInline } from './scan';
+import { inlineDescendants } from './walk';
+import { recordInlineCompute } from '../../perf/instruments';
+registerBuiltInDescriptors();
+/** Content range within a prose block's raw; marker-bearing kinds override via descriptor. */
+export function getContentRange(node) {
+    const d = getBlockKindDescriptor(node.kind);
+    if (d.getContentRange)
+        return d.getContentRange(node);
+    return { start: 0, end: displayLength(node.raw) };
+}
+/** The one {@link ContentLength} mint. */
+export function contentLengthOf(node) {
+    return getContentRange(node).end;
+}
+export function isProseKind(kind) {
+    return getBlockKindDescriptor(kind).supportsInline;
+}
+/**
+ * The bytes an INLINE construct's delimiters do not cover, or null for a kind that has none — a
+ * bare text run, an escape, a pair emptied of content. The inline twin of {@link getContentRange},
+ * here rather than beside one of its callers because the caret bounds, the typing seat, the
+ * destructive arm and the toggles all need the same answer.
+ */
+export function constructContentRange(node) {
+    const children = node.children;
+    if (children && children.length > 0) {
+        return { start: children[0].start, end: children[children.length - 1].end };
+    }
+    // A code span carries its content as `text` rather than children, and a matched span's two
+    // backtick runs are equal, so what the content does not cover splits evenly between them.
+    if (node.kind === 'inlineCode' && node.text !== undefined) {
+        const fence = (node.end - node.start - node.text.length) / 2;
+        if (Number.isInteger(fence) && fence > 0) {
+            return { start: node.start + fence, end: node.end - fence };
+        }
+    }
+    return null;
+}
+/**
+ * A prose node's inline tree, pure: no caching, no reactive reads. The render path calls this
+ * directly; the caching accessor (inline-cache.ts) calls it on a miss.
+ */
+export function computeInlineContent(node, resolver) {
+    recordInlineCompute();
+    const range = getContentRange(node);
+    return parseInline(node.raw, range.start, range.end, resolver);
+}
+// ── Inline Parser ──────────────────────────────────────────────────────────
+/**
+ * Parse inline content over raw[start, end). Node offsets are absolute into raw, and every byte
+ * lands in exactly one node's range. Both bounds are checked, not just typed: a caller the
+ * compiler cannot reach that passes only the source would otherwise get one whole-string text
+ * node, which is wrong output that looks like a result.
+ */
+export function parseInline(raw, start, end, resolver) {
+    if (!Number.isFinite(start) || !Number.isFinite(end)) {
+        throw new TypeError('parseInline requires both scan bounds — to scan a whole string, call parseInline(src, 0, src.length)');
+    }
+    return scanInline(raw, start, end, resolver);
+}
+// ── Inline Tree Walks ──────────────────────────────────────────────────────
+export { inlineDescendants };
+/** Every construct kind anywhere in a parse, at any depth. */
+export function constructKinds(nodes) {
+    const kinds = new Set();
+    for (const node of inlineDescendants(nodes))
+        if (node.kind !== 'text')
+            kinds.add(node.kind);
+    return kinds;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Lazy `inlineContent` accessor for non-render consumers, over a node-keyed WeakMap.
+ * Non-reactive by design: never call from the render path (which uses computeInlineContent),
+ * since a reactive read+write here re-introduces the keyed-`{#each}` corruption G4.2 guards.
+ * One sub-entry per signature space, so resolver-less and signature-bearing callers cannot
+ * evict each other on a bracket-bearing block.
+ */
+import type { InlineNode } from '../nodes';
+import type { NodeView } from '../node-views';
+import type { LinkReferenceResolver } from './link-reference-resolver';
+export declare function getInlineContent(node: NodeView, resolver?: LinkReferenceResolver, signature?: string): InlineNode[];
+/**
+ * The one spelling of `getInlineContent(node, ref.current, ref.signature)`, so a non-render
+ * call site cannot drop the signature and silently desync from what render drew. `linkRef`
+ * stays structural: naming editor-keys' type would cycle that module back onto this layer.
+ */
+export declare function resolvedInlineContent(node: NodeView, linkRef?: {
+    current?: LinkReferenceResolver;
+    signature?: string;
+}): InlineNode[];

package/dist/core/inline/inline-cache.js

@@ -0,0 +1,28 @@
+import { computeInlineContent, isProseKind } from './index';
+const cache = new WeakMap();
+export function getInlineContent(node, resolver, signature = '') {
+    if (!isProseKind(node.kind))
+        return [];
+    // A block resolves through an LRD only if it holds a bracket; mirroring the render gate keeps
+    // a bracketless block off both the resolver and the signature.
+    const hasRef = node.raw.includes('[');
+    const sig = hasRef ? signature : '';
+    const effectiveResolver = hasRef ? resolver : undefined;
+    const entry = cache.get(node);
+    const slot = sig === '' ? 'plain' : 'resolved';
+    const hit = entry?.[slot];
+    if (hit && hit.raw === node.raw && hit.signature === sig)
+        return hit.content;
+    const content = computeInlineContent(node, effectiveResolver);
+    // Spread, so refilling one slot carries the other one through untouched.
+    cache.set(node, { ...entry, [slot]: { raw: node.raw, signature: sig, content } });
+    return content;
+}
+/**
+ * The one spelling of `getInlineContent(node, ref.current, ref.signature)`, so a non-render
+ * call site cannot drop the signature and silently desync from what render drew. `linkRef`
+ * stays structural: naming editor-keys' type would cycle that module back onto this layer.
+ */
+export function resolvedInlineContent(node, linkRef) {
+    return getInlineContent(node, linkRef?.current, linkRef?.signature ?? '');
+}

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

@@ -0,0 +1,124 @@
+/**
+ * The single source of truth for which inline kinds render as live atomic widgets
+ * (contenteditable=false islands marked `[data-inline-widget]`) and how each is recognized.
+ * Recognition is registry-owned; DOM building dispatches by layer: a `buildWidget` for
+ * core-built widgets, a `component` mounted through the injected portal builder, or neither
+ * for the image, whose per-instance builder is injected per render.
+ */
+import type { Component } from 'svelte';
+import type { AnyInlineKind, InlineNode } from '../nodes';
+import type { DocumentView, NodeView } from '../node-views';
+import type { PresentationMode } from '../../presentation-mode';
+/**
+ * The atomic-widget shell every core builder shares. Its `data-*` attributes are the offset
+ * walk's only handle, so the shell is minted here once and builders add only the body.
+ */
+export declare function mintWidgetShell(className: string, node: InlineNode): HTMLSpanElement;
+/** The raw byte range a shell carries, or null when the attributes are absent or malformed —
+ *  {@link mintWidgetShell}'s inverse, so the mint and every read-back move together. */
+export declare function widgetSourceRange(el: Element): {
+    start: number;
+    end: number;
+} | null;
+/**
+ * Props a `component` widget kind is mounted with. Frozen at mount: the pool remounts on a
+ * source change, so `source` never shifts under a live instance, but `inline.start`/`end` CAN
+ * lag once adjacent typing moves the widget. The live position is the wrapper's re-stamped
+ * `data-source-*`, never these fields. The getters below are live for the same reason inverted:
+ * an instance the pool reuses would go stale on a frozen value.
+ */
+export interface InlineWidgetComponentProps {
+    inline: InlineNode;
+    source: string;
+    /** Absent reads as 'source'. */
+    getPresentationMode?: () => PresentationMode;
+    /** A widget whose body an ENGINE paints emits colors no stylesheet reaches, so it keys its
+     *  render on this. One styled with CSS tokens needs nothing here. Absent reads as 'dark'. */
+    getTheme?: () => string;
+    /** The pool keys on `${kind} ${source}`, so a widget whose value derives from the document
+     *  (footnote numbering) needs this to survive edits elsewhere that change no source. */
+    getDocument?: () => DocumentView | undefined;
+    /**
+     * Memo key for a whole-document derivation: the `$state` document is mutated in place, so
+     * its identity never changes and an identity-keyed memo would hit forever on stale data.
+     * Read it INSIDE the widget's `$derived`; that read is what subscribes it to edits anywhere.
+     */
+    getContentVersion?: () => number;
+    /** `EditorRects.navigateTo`: reveal, scroll and land the caret at a raw offset in a block
+     *  path. Absent in a bare harness, so a widget that navigates declines rather than throws. */
+    navigateTo?: (path: number[], offset?: number) => Promise<boolean>;
+}
+/**
+ * The editor's activation gesture, shared by the surface deciding whether to reveal and the
+ * widget deciding whether to act: a Ctrl/Cmd chord while editing, a plain click in reading
+ * mode, where there is no caret for a plain click to place. The link click's rule
+ * (`Editor.svelte`), applied to widgets.
+ */
+export declare function isWidgetActivationClick(modified: boolean, mode: PresentationMode): boolean;
+/** The closed vocabularies as values, so the published conformance kit checks a registration
+ *  against the type's own members rather than a copy that ages out of step with it. */
+export declare const DELETE_GRANULARITIES: readonly ["atomic", "select-then-delete"];
+export declare const ON_EDGE_POLICIES: readonly ["select", "step-over"];
+/**
+ * Per-kind editing behavior, read by the caret-edge dispatch
+ * (`components/blocks/text/edge-policy-dispatch.ts`). `atomic` deletes in one press where
+ * `select-then-delete` takes two; `onEdge` chooses between selecting the construct whole and
+ * stepping over it like a character.
+ */
+export interface InlineWidgetEditingPolicy {
+    revealSource?: boolean;
+    deleteGranularity?: (typeof DELETE_GRANULARITIES)[number];
+    onEdge?: (typeof ON_EDGE_POLICIES)[number];
+    onSelectedKey?: (e: KeyboardEvent, ctx: InlineWidgetEditingContext) => boolean;
+    /** The widget's own component handles an activation click ({@link isWidgetActivationClick}),
+     *  so the surface stands its reveal down rather than unmounting the widget under it. */
+    claimsActivationClick?: boolean;
+}
+export interface InlineWidgetEditingContext {
+    /** Bytes-readonly (G1.9); edits go through `updateContent`. */
+    node: NodeView;
+    inline: InlineNode;
+    widgetStart: number;
+    widgetEnd: number;
+    index: number;
+    preSelectOffset: number;
+    editorContentWidth: number;
+    /** Effective mode at dispatch; a handler declines edits in 'reading'. */
+    presentationMode: PresentationMode;
+    /** Bound by the caller: core cannot reach the editor-actions block API. */
+    updateContent: (newRaw: string, caretBefore: number, caretAfter: number) => void;
+}
+export interface InlineWidgetDescriptor {
+    isWidget(node: InlineNode, raw: string): boolean;
+    /** Omitted for a kind whose builder is injected per render (image) or that uses `component`. */
+    buildWidget?(node: InlineNode, raw: string): HTMLElement;
+    /** The recommended path, mutually exclusive with `buildWidget`: the render layer wraps it in
+     *  the atomic-island span and mounts it through the injected portal builder. */
+    component?: Component<InlineWidgetComponentProps>;
+    editing?: InlineWidgetEditingPolicy;
+}
+export declare function registerInlineWidgetKind(kind: AnyInlineKind, descriptor: InlineWidgetDescriptor): void;
+/**
+ * Layer editing fields onto an already-registered kind. The editor-layer wire-up
+ * (components/built-in-blocks.ts) attaches behavior here that would otherwise make a core
+ * registration import a downstream layer. Throws for an unregistered kind.
+ */
+export declare function augmentInlineWidgetKind(kind: AnyInlineKind, editing: Partial<InlineWidgetEditingPolicy>): void;
+/** Kind-level recognition, independent of per-block render policy (renderImagesAsWidgets). */
+export declare function isInlineWidget(node: InlineNode, raw: string): boolean;
+export declare function getInlineWidgetEditing(kind: AnyInlineKind): InlineWidgetEditingPolicy | undefined;
+export declare function getInlineWidgetComponent(kind: AnyInlineKind): Component<InlineWidgetComponentProps> | undefined;
+/**
+ * Every live widget reachable from `nodes`, in document order. Descends so a widget nested in a
+ * non-widget parent is found (the `image` inside `[![alt][ref]][repo]`), but never into a
+ * widget's own children, which are atomic. `raw` is the enclosing block's source.
+ */
+export declare function flattenInlineWidgets(nodes: ReadonlyArray<InlineNode>, raw: string): InlineNode[];
+/**
+ * A `component` kind routes through the injected `buildPortalWidget` because the component layer
+ * owns Svelte mounting and `core/` stays framework-free. Null when the node is not a widget, its
+ * builder is injected per render (image), or the portal builder is absent or failed.
+ */
+export declare function buildCoreInlineWidget(node: InlineNode, raw: string, buildPortalWidget?: (node: InlineNode, raw: string) => HTMLElement | null): HTMLElement | null;
+/** Test-only. Removes every plugin-registered inline-widget kind; built-ins survive. */
+export declare function __resetInlineWidgetsForTests(): void;

package/dist/core/inline/inline-widgets.js

@@ -0,0 +1,131 @@
+/**
+ * The single source of truth for which inline kinds render as live atomic widgets
+ * (contenteditable=false islands marked `[data-inline-widget]`) and how each is recognized.
+ * Recognition is registry-owned; DOM building dispatches by layer: a `buildWidget` for
+ * core-built widgets, a `component` mounted through the injected portal builder, or neither
+ * for the image, whose per-instance builder is injected per render.
+ */
+import { isLiveHtmlTag, buildLiveHtmlWidget } from './raw-html-widget';
+import { entityRendersGlyph, buildEntityWidget } from './entity-widget';
+import { registerOnce } from '../../schema/register-once';
+import { inlineDescendants } from './walk';
+/**
+ * The atomic-widget shell every core builder shares. Its `data-*` attributes are the offset
+ * walk's only handle, so the shell is minted here once and builders add only the body.
+ */
+export function mintWidgetShell(className, node) {
+    const shell = document.createElement('span');
+    shell.className = className;
+    shell.dataset.inlineWidget = '';
+    shell.dataset.sourceStart = String(node.start);
+    shell.dataset.sourceEnd = String(node.end);
+    shell.setAttribute('contenteditable', 'false');
+    return shell;
+}
+/** The raw byte range a shell carries, or null when the attributes are absent or malformed —
+ *  {@link mintWidgetShell}'s inverse, so the mint and every read-back move together. */
+export function widgetSourceRange(el) {
+    const start = parseInt(el.getAttribute('data-source-start') ?? '', 10);
+    const end = parseInt(el.getAttribute('data-source-end') ?? '', 10);
+    if (Number.isNaN(start) || Number.isNaN(end))
+        return null;
+    return { start, end };
+}
+/**
+ * The editor's activation gesture, shared by the surface deciding whether to reveal and the
+ * widget deciding whether to act: a Ctrl/Cmd chord while editing, a plain click in reading
+ * mode, where there is no caret for a plain click to place. The link click's rule
+ * (`Editor.svelte`), applied to widgets.
+ */
+export function isWidgetActivationClick(modified, mode) {
+    return modified || mode === 'reading';
+}
+/** The closed vocabularies as values, so the published conformance kit checks a registration
+ *  against the type's own members rather than a copy that ages out of step with it. */
+export const DELETE_GRANULARITIES = ['atomic', 'select-then-delete'];
+export const ON_EDGE_POLICIES = ['select', 'step-over'];
+const registry = new Map();
+export function registerInlineWidgetKind(kind, descriptor) {
+    if (descriptor.component && descriptor.buildWidget) {
+        throw new Error(`registerInlineWidgetKind: "${kind}" declares both a component and a buildWidget — ` +
+            `a widget kind renders through exactly one. Drop one.`);
+    }
+    registerOnce(registry.has(kind), () => registry.set(kind, descriptor), `registerInlineWidgetKind: "${kind}" is already registered. Inline-widget kinds are ` +
+        `register-once — a re-registration would clobber a built-in (image/rawHtml).`);
+}
+/**
+ * Layer editing fields onto an already-registered kind. The editor-layer wire-up
+ * (components/built-in-blocks.ts) attaches behavior here that would otherwise make a core
+ * registration import a downstream layer. Throws for an unregistered kind.
+ */
+export function augmentInlineWidgetKind(kind, editing) {
+    const descriptor = registry.get(kind);
+    if (!descriptor) {
+        throw new Error(`augmentInlineWidgetKind: "${kind}" is not registered — register the widget kind before ` +
+            `augmenting its editing policy.`);
+    }
+    descriptor.editing = { ...descriptor.editing, ...editing };
+}
+/** Kind-level recognition, independent of per-block render policy (renderImagesAsWidgets). */
+export function isInlineWidget(node, raw) {
+    const descriptor = registry.get(node.kind);
+    return descriptor ? descriptor.isWidget(node, raw) : false;
+}
+export function getInlineWidgetEditing(kind) {
+    return registry.get(kind)?.editing;
+}
+export function getInlineWidgetComponent(kind) {
+    return registry.get(kind)?.component;
+}
+/**
+ * Every live widget reachable from `nodes`, in document order. Descends so a widget nested in a
+ * non-widget parent is found (the `image` inside `[![alt][ref]][repo]`), but never into a
+ * widget's own children, which are atomic. `raw` is the enclosing block's source.
+ */
+export function flattenInlineWidgets(nodes, raw) {
+    const out = [];
+    for (const node of inlineDescendants(nodes, (parent) => !isInlineWidget(parent, raw))) {
+        if (isInlineWidget(node, raw))
+            out.push(node);
+    }
+    return out;
+}
+/**
+ * A `component` kind routes through the injected `buildPortalWidget` because the component layer
+ * owns Svelte mounting and `core/` stays framework-free. Null when the node is not a widget, its
+ * builder is injected per render (image), or the portal builder is absent or failed.
+ */
+export function buildCoreInlineWidget(node, raw, buildPortalWidget) {
+    const descriptor = registry.get(node.kind);
+    if (!descriptor || !descriptor.isWidget(node, raw))
+        return null;
+    if (descriptor.component)
+        return buildPortalWidget?.(node, raw) ?? null;
+    return descriptor.buildWidget ? descriptor.buildWidget(node, raw) : null;
+}
+registerInlineWidgetKind('image', {
+    isWidget: () => true,
+    // Empty because the image's edge behavior is the dispatch's default; the editor layer
+    // augments this with the resize `onSelectedKey` (components/built-in-blocks.ts).
+    editing: {}
+});
+registerInlineWidgetKind('rawHtml', {
+    isWidget: (node, raw) => isLiveHtmlTag(raw.slice(node.start, node.end)),
+    buildWidget: (node) => buildLiveHtmlWidget(node)
+});
+// Gated to visibly-rendering glyphs: an invisible entity keeps its literal-source span rather
+// than becoming an atomic island the caret cannot see.
+registerInlineWidgetKind('entityReference', {
+    isWidget: (node) => entityRendersGlyph(node.decoded),
+    buildWidget: (node) => buildEntityWidget(node),
+    editing: { deleteGranularity: 'atomic', onEdge: 'step-over' }
+});
+// Must stay below the built-in registrations: it snapshots what the test reset may not drop.
+const BUILTIN_INLINE_WIDGET_KINDS = new Set(registry.keys());
+/** Test-only. Removes every plugin-registered inline-widget kind; built-ins survive. */
+export function __resetInlineWidgetsForTests() {
+    for (const kind of registry.keys()) {
+        if (!BUILTIN_INLINE_WIDGET_KINDS.has(kind))
+            registry.delete(kind);
+    }
+}

package/dist/core/inline/link-reference-resolver.d.ts

@@ -0,0 +1,21 @@
+/** CommonMark §4.7 label normalization plus the resolver built from LRD nodes. */
+import type { CstNode } from '../nodes';
+/** CommonMark §4.7 normalization. BMP-only: full Unicode case-fold is deferred until reported. */
+export declare function normalizeLinkLabel(raw: string): string;
+export type ResolvedReference = Readonly<{
+    url: string;
+    title?: string;
+}>;
+export type LinkReferenceResolver = (label: string) => ResolvedReference | undefined;
+export interface LinkReferenceMap {
+    /** Takes a non-normalized label. */
+    resolve: LinkReferenceResolver;
+    /**
+     * Stable snapshot of the LRD set. The lazy inline cache validates reference-bearing blocks
+     * on it, so an LRD change elsewhere re-resolves them. The render path keys on a compact
+     * epoch instead, never this string: it reaches ~MB scale in reference-heavy documents.
+     */
+    readonly signature: string;
+}
+/** Collects LRDs nested inside containers too. First-wins on duplicate labels (§4.7). */
+export declare function buildLinkReferenceMap(nodes: CstNode[]): LinkReferenceMap;

package/dist/core/inline/link-reference-resolver.js

@@ -0,0 +1,46 @@
+/** CommonMark §4.7 label normalization plus the resolver built from LRD nodes. */
+import { metadataOf } from '../nodes';
+/** CommonMark §4.7 normalization. BMP-only: full Unicode case-fold is deferred until reported. */
+export function normalizeLinkLabel(raw) {
+    return raw.trim().replace(/\s+/g, ' ').toLowerCase();
+}
+/** Collects LRDs nested inside containers too. First-wins on duplicate labels (§4.7). */
+export function buildLinkReferenceMap(nodes) {
+    const entries = new Map();
+    collectLinkReferences(nodes, entries);
+    const sigParts = [];
+    for (const [label, ref] of entries) {
+        sigParts.push(`${label}<:>${ref.url}<:>${ref.title ?? ''}`);
+    }
+    sigParts.sort();
+    const signature = sigParts.join('|');
+    return {
+        resolve: (label) => entries.get(normalizeLinkLabel(label)),
+        signature
+    };
+}
+function collectLinkReferences(nodes, entries) {
+    const stack = [];
+    // Reversed push, so pop order is document order — which is what first-wins reads.
+    const push = (level) => {
+        for (let i = level.length - 1; i >= 0; i--)
+            stack.push(level[i]);
+    };
+    push(nodes);
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.kind === 'linkReferenceDefinition') {
+            const meta = metadataOf(node, 'linkReferenceDefinition');
+            if (meta?.label === undefined || meta.url === undefined)
+                continue;
+            const key = normalizeLinkLabel(meta.label);
+            if (entries.has(key))
+                continue; // first-wins
+            entries.set(key, meta.title !== undefined
+                ? Object.freeze({ url: meta.url, title: meta.title })
+                : Object.freeze({ url: meta.url }));
+        }
+        if (node.children)
+            push(node.children);
+    }
+}

package/dist/core/inline/raw-html-widget.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Allowlist and builder for live-rendered inline HTML widgets. They adopt the generic
+ * `[data-inline-widget]` marker, so cursor, vertical-skip, and edge-select need no per-kind
+ * plumbing (`cursor/widget-offset.ts`).
+ */
+import type { InlineNode } from '../nodes';
+/** Comments, PIs, declarations, and CDATA never match: they have no tag name. */
+export declare function isLiveHtmlTag(slice: string): boolean;
+/** The outer span is the shell the cursor machinery recognizes; the inner `<br>` breaks. */
+export declare function buildLiveHtmlWidget(node: InlineNode): HTMLSpanElement;

package/dist/core/inline/raw-html-widget.js

@@ -0,0 +1,22 @@
+/**
+ * Allowlist and builder for live-rendered inline HTML widgets. They adopt the generic
+ * `[data-inline-widget]` marker, so cursor, vertical-skip, and edge-select need no per-kind
+ * plumbing (`cursor/widget-offset.ts`).
+ */
+import { mintWidgetShell } from './inline-widgets';
+/** A tag from GFM §6.11's disallowed-raw-HTML list must never be added here. */
+const LIVE_HTML_TAGS = new Set(['br']);
+const TAG_NAME_EXTRACT = /^<\/?([A-Za-z][A-Za-z0-9-]*)/;
+/** Comments, PIs, declarations, and CDATA never match: they have no tag name. */
+export function isLiveHtmlTag(slice) {
+    const m = TAG_NAME_EXTRACT.exec(slice);
+    if (!m)
+        return false;
+    return LIVE_HTML_TAGS.has(m[1].toLowerCase());
+}
+/** The outer span is the shell the cursor machinery recognizes; the inner `<br>` breaks. */
+export function buildLiveHtmlWidget(node) {
+    const shell = mintWidgetShell('md-br-widget', node);
+    shell.appendChild(document.createElement('br'));
+    return shell;
+}