@voithos-labs/aragonite 0.10.3 → 0.10.7

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

@@ -1,17 +1,17 @@
 /**
- * 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.
+ * The one registry of which inline kinds render as live widgets (non-editable spans marked
+ * `[data-inline-widget]`) and how each is recognized. DOM building has three routes: a
+ * `buildWidget` for core-built widgets, a `component` mounted through the injected portal
+ * builder, or neither for the image, whose builder is injected per render.
  */
+import { isBuiltinInlineKind } from '../nodes';
 import { isLiveHtmlTag, buildLiveHtmlWidget } from './raw-html-widget';
 import { entityRendersGlyph, buildEntityWidget } from './entity-widget';
-import { registerOnce } from '../../schema/register-once';
+import { createInlineKindRegistry } from '../../schema/plugin-registry';
 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.
+ * The widget shell every core builder shares. Its `data-*` attributes are the only handle the
+ * DOM-to-offset traversal has, so the shell is created here once and builders add only the body.
  */
 export function mintWidgetShell(className, node) {
     const shell = document.createElement('span');
@@ -22,8 +22,8 @@ export function mintWidgetShell(className, node) {
     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. */
+/** The raw byte range a shell carries, or null when the attributes are absent or malformed:
+ *  {@link mintWidgetShell}'s inverse, kept beside it so the two move together. */
 export function widgetSourceRange(el) {
     const start = parseInt(el.getAttribute('data-source-start') ?? '', 10);
     const end = parseInt(el.getAttribute('data-source-end') ?? '', 10);
@@ -31,12 +31,8 @@ export function widgetSourceRange(el) {
         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.
- */
+/** Shared by the editable element deciding whether to show the source and the widget deciding
+ *  whether to act. Reading mode has no caret to place, so a plain click activates, as for links. */
 export function isWidgetActivationClick(modified, mode) {
     return modified || mode === 'reading';
 }
@@ -44,59 +40,69 @@ export function isWidgetActivationClick(modified, mode) {
  *  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();
+const registry = createInlineKindRegistry({
+    label: 'registerInlineWidgetKind',
+    isBuiltin: isBuiltinInlineKind
+});
+/** The kind's descriptor under an editor's grammar: absent where the editor left out the plugin
+ *  the entry answers to, so a node of that kind renders as its source. */
+function widgetOf(kind, grammar) {
+    return registry.get(kind, grammar.activation);
+}
 export function registerInlineWidgetKind(kind, descriptor) {
     if (descriptor.component && descriptor.buildWidget) {
-        throw new Error(`registerInlineWidgetKind: "${kind}" declares both a component and a 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 ` +
+    registry.register(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.
- */
+/** Lets the editor layer (`components/built-in-blocks.ts`) attach editing behavior without a core
+ *  registration importing it. Throws for an unregistered kind. */
 export function augmentInlineWidgetKind(kind, editing) {
-    const descriptor = registry.get(kind);
+    const descriptor = registry.getIgnoringActivation(kind);
     if (!descriptor) {
-        throw new Error(`augmentInlineWidgetKind: "${kind}" is not registered — register the widget kind before ` +
+        throw new Error(`augmentInlineWidgetKind: "${kind}" is not registered; register the widget kind before ` +
             `augmenting its editing policy.`);
     }
     descriptor.editing = { ...descriptor.editing, ...editing };
 }
+// Each lookup below takes the editor's grammar, which leaves out the plugins it did not list.
+/** Whether the kind renders as a widget under the editor's grammar, whatever one node's bytes. */
+export function isInlineWidgetKind(kind, grammar) {
+    return widgetOf(kind, grammar) !== undefined;
+}
 /** Kind-level recognition, independent of per-block render policy (renderImagesAsWidgets). */
-export function isInlineWidget(node, raw) {
-    const descriptor = registry.get(node.kind);
+export function isInlineWidget(node, raw, grammar) {
+    const descriptor = widgetOf(node.kind, grammar);
     return descriptor ? descriptor.isWidget(node, raw) : false;
 }
-export function getInlineWidgetEditing(kind) {
-    return registry.get(kind)?.editing;
+export function getInlineWidgetEditing(kind, grammar) {
+    return widgetOf(kind, grammar)?.editing;
 }
-export function getInlineWidgetComponent(kind) {
-    return registry.get(kind)?.component;
+/** A kind the caret treats as one character: it steps over in one keypress, has a column of its
+ *  own, and a click on its glyph names an edge rather than selecting the widget whole. */
+export function isCharacterLikeWidget(kind, grammar) {
+    return getInlineWidgetEditing(kind, grammar)?.onEdge === 'step-over';
 }
-/**
- * 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) {
+export function getInlineWidgetComponent(kind, grammar) {
+    return widgetOf(kind, grammar)?.component;
+}
+/** Descends into non-widget parents (the `image` inside `[![alt][ref]][repo]`) but never into a
+ *  widget, whose children are atomic. `raw` is the enclosing block's source. */
+export function flattenInlineWidgets(nodes, raw, grammar) {
     const out = [];
-    for (const node of inlineDescendants(nodes, (parent) => !isInlineWidget(parent, raw))) {
-        if (isInlineWidget(node, raw))
+    const isWidget = (node) => isInlineWidget(node, raw, grammar);
+    for (const node of inlineDescendants(nodes, (parent) => !isWidget(parent))) {
+        if (isWidget(node))
             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);
+/** A `component` kind mounts through the injected `buildPortalWidget`, keeping `core/` free of
+ *  Svelte. Null for a non-widget, an image (built per render), or a missing or failed portal. */
+export function buildCoreInlineWidget(node, raw, buildPortalWidget, grammar) {
+    const descriptor = widgetOf(node.kind, grammar);
     if (!descriptor || !descriptor.isWidget(node, raw))
         return null;
     if (descriptor.component)
@@ -113,19 +119,10 @@ 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.
+// Only an entity that draws a glyph becomes a widget: an invisible one keeps its literal-source
+// span, or the caret would step over something it 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-destination.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The link label, destination and title grammar (CommonMark §6.3), read by inline and reference
+ * links and by link reference definitions (§4.7) alike. Each function returns where its span ends
+ * and, for a destination or title, the value the spec derives from it; the whitespace between the
+ * parts is each caller's rule. The inverse writer is `destination-bytes.ts`.
+ */
+export interface LinkDestination {
+    /** Escapes and entities resolved, then percent-encoded. */
+    url: string;
+    end: number;
+}
+export interface LinkTitle {
+    /** Escapes and entities resolved. */
+    title: string;
+    end: number;
+}
+/** A scan that reached `end` inside an open label or title; more text may still close it. */
+export declare const SPAN_OPEN = -2;
+/** The offset just past the label's `]`, or null. */
+export declare function parseLinkLabel(raw: string, pos: number, end: number): number | null;
+/** Where the label opening at `pos` ends: past its `]`, `SPAN_OPEN`, or negative for no label (over
+ *  999 characters, or an unescaped `[`). `from` resumes an open scan at the `end` it stopped on. */
+export declare function scanLinkLabel(raw: string, pos: number, end: number, from: number): number;
+/** A bare destination is empty only just before a `)`, which only an inline link can close on. */
+export declare function parseLinkDestination(raw: string, pos: number, end: number): LinkDestination | null;
+export declare function parseLinkTitle(raw: string, pos: number, end: number): LinkTitle | null;
+/** Where the title opening at `pos` ends: past its closer, `SPAN_OPEN`, or negative for no title.
+ *  `from` resumes an open scan at the `end` it stopped on. */
+export declare function scanLinkTitle(raw: string, pos: number, end: number, from: number): number;
+/** The value of the title spanning `pos` to `titleEnd`, a span `scanLinkTitle` accepted. */
+export declare function linkTitleValue(raw: string, pos: number, titleEnd: number): string;

package/dist/core/inline/link-destination.js

@@ -0,0 +1,129 @@
+/**
+ * The link label, destination and title grammar (CommonMark §6.3), read by inline and reference
+ * links and by link reference definitions (§4.7) alike. Each function returns where its span ends
+ * and, for a destination or title, the value the spec derives from it; the whitespace between the
+ * parts is each caller's rule. The inverse writer is `destination-bytes.ts`.
+ */
+import { ESCAPABLE_PUNCTUATION } from '../escapable';
+import { processDestination, unescapeSpecString } from './scan/url';
+/** A scan that reached `end` inside an open label or title; more text may still close it. */
+export const SPAN_OPEN = -2;
+const NOT_A_SPAN = -1;
+// ── Labels ──────────────────────────────────────────────────────────────────
+/** The offset just past the label's `]`, or null. */
+export function parseLinkLabel(raw, pos, end) {
+    const labelEnd = scanLinkLabel(raw, pos, end, pos + 1);
+    return labelEnd < 0 ? null : labelEnd;
+}
+/** Where the label opening at `pos` ends: past its `]`, `SPAN_OPEN`, or negative for no label (over
+ *  999 characters, or an unescaped `[`). `from` resumes an open scan at the `end` it stopped on. */
+export function scanLinkLabel(raw, pos, end, from) {
+    if (raw[pos] !== '[')
+        return NOT_A_SPAN;
+    let i = from;
+    while (i < end) {
+        if (i - pos > 1000)
+            return NOT_A_SPAN;
+        const ch = raw[i];
+        if (ch === ']')
+            return i + 1;
+        if (ch === '[')
+            return NOT_A_SPAN;
+        i += ch === '\\' ? 2 : 1;
+    }
+    return i - pos > 1000 ? NOT_A_SPAN : SPAN_OPEN;
+}
+// ── Destinations ────────────────────────────────────────────────────────────
+/** A bare destination is empty only just before a `)`, which only an inline link can close on. */
+export function parseLinkDestination(raw, pos, end) {
+    if (pos < end && raw[pos] === '<')
+        return parseAngleDestination(raw, pos, end);
+    return parseBareDestination(raw, pos, end);
+}
+function parseAngleDestination(raw, pos, end) {
+    let i = pos + 1;
+    while (i < end) {
+        const ch = raw[i];
+        if (ch === '>')
+            return { url: processDestination(raw.slice(pos + 1, i)), end: i + 1 };
+        if (ch === '<' || ch === '\n' || ch === '\u0000')
+            return null;
+        if (ch === '\\') {
+            // A backslash escapes no line terminator, JavaScript's four included.
+            const next = i + 1 < end ? raw[i + 1] : '';
+            if (next === '' || next === '\n' || next === '\r' || next === '\u2028' || next === '\u2029') {
+                return null;
+            }
+            i += 2;
+        }
+        else {
+            i++;
+        }
+    }
+    return null;
+}
+// commonmark.js's terminator set: other control characters, and U+00A0, are destination content.
+const DESTINATION_TERMINATORS = new Set(' \t\n\u000b\u000c\r');
+/** Parentheses must balance, at any depth. */
+function parseBareDestination(raw, pos, end) {
+    let i = pos;
+    let openParens = 0;
+    while (i < end) {
+        const ch = raw[i];
+        if (ch === '\\' && i + 1 < end && ESCAPABLE_PUNCTUATION.has(raw[i + 1])) {
+            i += 2;
+        }
+        else if (ch === '(') {
+            openParens++;
+            i++;
+        }
+        else if (ch === ')') {
+            if (openParens < 1)
+                break;
+            openParens--;
+            i++;
+        }
+        else if (DESTINATION_TERMINATORS.has(ch)) {
+            break;
+        }
+        else {
+            i++;
+        }
+    }
+    if (i === pos && (i >= end || raw[i] !== ')'))
+        return null;
+    if (openParens !== 0)
+        return null;
+    return { url: processDestination(raw.slice(pos, i)), end: i };
+}
+// ── Titles ──────────────────────────────────────────────────────────────────
+export function parseLinkTitle(raw, pos, end) {
+    const titleEnd = scanLinkTitle(raw, pos, end, pos + 1);
+    return titleEnd < 0 ? null : { title: linkTitleValue(raw, pos, titleEnd), end: titleEnd };
+}
+/** Where the title opening at `pos` ends: past its closer, `SPAN_OPEN`, or negative for no title.
+ *  `from` resumes an open scan at the `end` it stopped on. */
+export function scanLinkTitle(raw, pos, end, from) {
+    const marker = raw[pos];
+    if (marker !== '"' && marker !== "'" && marker !== '(')
+        return NOT_A_SPAN;
+    const close = marker === '(' ? ')' : marker;
+    let i = from;
+    while (i < end) {
+        const ch = raw[i];
+        if (ch === close)
+            return i + 1;
+        // A paren title cannot nest.
+        if (ch === '\u0000' || (marker === '(' && ch === '('))
+            return NOT_A_SPAN;
+        if (ch === '\\' && i + 1 < end)
+            i += 2;
+        else
+            i++;
+    }
+    return SPAN_OPEN;
+}
+/** The value of the title spanning `pos` to `titleEnd`, a span `scanLinkTitle` accepted. */
+export function linkTitleValue(raw, pos, titleEnd) {
+    return unescapeSpecString(raw.slice(pos + 1, titleEnd - 1));
+}

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

@@ -1,6 +1,8 @@
-/** CommonMark §4.7 label normalization plus the resolver built from LRD nodes. */
+/** Link label matching (GFM §6.6) and the resolver built from a document's link reference
+ *  definitions. */
 import type { CstNode } from '../nodes';
-/** CommonMark §4.7 normalization. BMP-only: full Unicode case-fold is deferred until reported. */
+/** GFM §6.6 label normalization, lowercasing rather than full Unicode case folding. Whitespace
+ *  is §2.1's ASCII set, so `[a<NBSP>b]` and `[a b]` are different labels. */
 export declare function normalizeLinkLabel(raw: string): string;
 export type ResolvedReference = Readonly<{
     url: string;
@@ -11,11 +13,11 @@ 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.
+     * Stable snapshot of the definition set, which the lazy inline cache keys on. The render path
+     * keys on a small counter instead: this string reaches megabytes in reference-heavy documents.
      */
     readonly signature: string;
 }
-/** Collects LRDs nested inside containers too. First-wins on duplicate labels (§4.7). */
+/** Collects link reference definitions nested in containers too; a label's first definition
+ *  wins (§4.7). */
 export declare function buildLinkReferenceMap(nodes: CstNode[]): LinkReferenceMap;

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

@@ -1,10 +1,14 @@
-/** CommonMark §4.7 label normalization plus the resolver built from LRD nodes. */
+/** Link label matching (GFM §6.6) and the resolver built from a document's link reference
+ *  definitions. */
 import { metadataOf } from '../nodes';
-/** CommonMark §4.7 normalization. BMP-only: full Unicode case-fold is deferred until reported. */
+import { trimWhitespace, WHITESPACE_RUN } from '../lines';
+/** GFM §6.6 label normalization, lowercasing rather than full Unicode case folding. Whitespace
+ *  is §2.1's ASCII set, so `[a<NBSP>b]` and `[a b]` are different labels. */
 export function normalizeLinkLabel(raw) {
-    return raw.trim().replace(/\s+/g, ' ').toLowerCase();
+    return trimWhitespace(raw).split(WHITESPACE_RUN).join(' ').toLowerCase();
 }
-/** Collects LRDs nested inside containers too. First-wins on duplicate labels (§4.7). */
+/** Collects link reference definitions nested in containers too; a label's first definition
+ *  wins (§4.7). */
 export function buildLinkReferenceMap(nodes) {
     const entries = new Map();
     collectLinkReferences(nodes, entries);
@@ -21,7 +25,7 @@ export function buildLinkReferenceMap(nodes) {
 }
 function collectLinkReferences(nodes, entries) {
     const stack = [];
-    // Reversed push, so pop order is document order — which is what first-wins reads.
+    // Reversed push, so pop order is document order and the first definition wins.
     const push = (level) => {
         for (let i = level.length - 1; i >= 0; i--)
             stack.push(level[i]);
@@ -35,7 +39,7 @@ function collectLinkReferences(nodes, entries) {
                 continue;
             const key = normalizeLinkLabel(meta.label);
             if (entries.has(key))
-                continue; // first-wins
+                continue;
             entries.set(key, meta.title !== undefined
                 ? Object.freeze({ url: meta.url, title: meta.title })
                 : Object.freeze({ url: meta.url }));

package/dist/core/inline/link-source-bytes.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Where a link edit becomes bytes: the functions every link write goes through, and under them
+ * the GFM serializer. A candidate is written only when the rendered text stays the same, since a
+ * destination that breaks its own construct shows up as literal source.
+ */
+import type { Reading } from '../../schema/reading';
+import type { InlineNode } from '../nodes';
+export interface LinkFields {
+    /** The link text's inner bytes, verbatim. Never re-escaped: the text can hold whole nested
+     *  constructs, and rewriting them from the parse would change 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 is refused, as on a node a plugin's
+ *  inline syntax owns: built-in grammar written over it would destroy that syntax. */
+export declare function buildLinkEditBytes(link: InlineNode, display: string, fields: LinkFields, reading: Reading): string | null;
+/** Bytes that unwrap `link` to the text the user already sees (remove link). An autolink has no
+ *  brackets, so its unwrap escapes the byte that would link it again. */
+export declare function buildLinkUnwrapBytes(link: InlineNode, display: string, reading: Reading): string | null;
+/** Bytes that write `[text](url)` over `[start, end)`, or null for an empty url, a range crossing
+ *  another construct, or a wrap that changes the render (a `!` before it makes an image). */
+export declare function buildLinkWrapBytes(display: string, start: number, end: number, url: string, reading: Reading): string | null;
+/** True when `[start, end)` holds only plain text, so a wrap crosses no other construct. */
+export declare function canWrapRangeAsLink(display: string, start: number, end: number, reading: Reading): boolean;
+/** The fields the link editor edits: `url` and `title` decoded off the node, the text and the
+ *  reference tail as the author wrote them. */
+export declare function linkFieldsFromInline(link: InlineNode, display: string): LinkFields;

package/dist/{components/blocks/text → core/inline}/link-source-bytes.js

@@ -1,54 +1,48 @@
 /**
- * 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.
+ * Where a link edit becomes bytes: the functions every link write goes through, and under them
+ * the GFM serializer. A candidate is written only when the rendered text stays the same, since a
+ * destination that breaks its own construct shows up as literal source.
  */
-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) {
+import { inlineDescendants, readInline } from './index';
+import { encodeDestination, escapeTitle } from './destination-bytes';
+import { CONTENT_VISIBILITY, renderedText } from './visibility';
+import { devWarn } from '../../dev-warn';
+/** Bytes to splice over `link`'s range, or null when the edit is refused, as on a node a plugin's
+ *  inline syntax owns: built-in grammar written over it would destroy that syntax. */
+export function buildLinkEditBytes(link, display, fields, reading) {
     if (declineClaimed(link, 'edit'))
         return null;
-    return verified(buildLinkSourceBytes(fields), link.start, link.end, display, resolver);
+    return verified(buildLinkSourceBytes(fields), link.start, link.end, display, reading);
 }
-/** 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) {
+/** Bytes that unwrap `link` to the text the user already sees (remove link). An autolink has no
+ *  brackets, so its unwrap escapes the byte that would link it again. */
+export function buildLinkUnwrapBytes(link, display, reading) {
     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);
+    return verified(escapeRelinkingText(plain, link, display, reading), link.start, link.end, display, reading);
 }
-/** 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))
+/** Bytes that write `[text](url)` over `[start, end)`, or null for an empty url, a range crossing
+ *  another construct, or a wrap that changes the render (a `!` before it makes an image). */
+export function buildLinkWrapBytes(display, start, end, url, reading) {
+    if (url.trim() === '' || !canWrapRangeAsLink(display, start, end, reading))
         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);
+    return verified(`[${text}](${encodeDestination(url)})`, start, end, display, reading);
 }
 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) {
+/** True when `[start, end)` holds only plain text, so a wrap crosses no other construct. */
+export function canWrapRangeAsLink(display, start, end, reading) {
     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);
+    return flattenInline(readInline(display, 0, display.length, reading.resolver, reading.grammar)).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. */
+/** The fields the link editor edits: `url` and `title` decoded off the node, the text and the
+ *  reference tail as the author wrote them. */
 export function linkFieldsFromInline(link, display) {
     const [textStart, textEnd] = textRange(link, display);
     return {
@@ -59,8 +53,8 @@ export function linkFieldsFromInline(link, display) {
     };
 }
 // ── 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. */
+/** The built-in grammar's inverse, called only by the functions above, which decide whether the
+ *  bytes are GFM's to write. */
 function buildLinkSourceBytes(fields) {
     if (fields.reference !== undefined)
         return `[${fields.text}]${fields.reference}`;
@@ -72,23 +66,21 @@ 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`);
+    devWarn('link-edit', `${what} declined: the "${claim.prefix}" inline syntax handler 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);
+/** What the user sees for `raw` in the content reading: the link editor may edit a destination
+ *  whose markers are on screen, which the block's own reading would count as a visible change. */
+function visibleText(raw, reading) {
+    return renderedText(readInline(raw, 0, raw.length, reading.resolver, reading.grammar), raw, CONTENT_VISIBILITY, { grammar: reading.grammar });
 }
-/** 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) {
+/** A candidate becomes bytes only if splicing it over `[start, end)` leaves the visible text
+ *  untouched: the write moves bytes nobody saw, so any visible change means the construct broke. */
+function verified(candidate, start, end, display, reading) {
     if (candidate === null)
         return null;
-    const before = visibleText(display, resolver);
-    const after = visibleText(spliced(candidate, start, end, display), resolver);
+    const before = visibleText(display, reading);
+    const after = visibleText(spliced(candidate, start, end, display), reading);
     return before === after ? candidate : null;
 }
 function spliced(candidate, start, end, display) {
@@ -114,16 +106,13 @@ const TRIGGER_ESCAPE = [
     [/^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) {
+/** Escapes the byte that makes unwrapped text a bare autolink again (`[www.x.com](u)`), so a
+ *  removed link stays removed and no visible character changes. */
+function escapeRelinkingText(text, link, display, reading) {
     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);
+        const offender = relinkedRange(candidate, link, display, reading);
         if (offender === null)
             return candidate;
         const escaped = escapeTrigger(candidate, offender);
@@ -134,10 +123,10 @@ function escapeRelinkingText(text, link, display, resolver) {
     return null;
 }
 /** The candidate-relative range of the first link the splice re-created, or null when clean. */
-function relinkedRange(candidate, link, display, resolver) {
+function relinkedRange(candidate, link, display, reading) {
     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);
+    const found = flattenInline(readInline(raw, 0, raw.length, reading.resolver, reading.grammar)).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,

package/dist/core/inline/live-edit/read-back.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A live rewrite's candidate read back where it will be stored (`docs/design/live-mode.md` § 2):
+ * through the position's write rules and read at its slot, as a reload reads it there. Every
+ * rewrite that removes bytes reads its candidate through here.
+ */
+import type { CstNode, InlineNode } from '../../nodes';
+import type { NodeView } from '../../node-views';
+import type { StoredAs } from '../../../schema/stored-as';
+export interface ReadBack {
+    /** The bytes the position stores. */
+    raw: string;
+    /** The one prose block they read as, or null on an inline surface. */
+    block: CstNode | null;
+    /** The inline tree, in the block's raw coordinates, or the stored bytes' on an inline surface. */
+    inlines: InlineNode[];
+    /** Leading space the reload moves into the container's marker (`- ` read as `-  `): off the
+     *  block, but still drawn, as the marker's width. */
+    lead: string;
+}
+/** `bytes` as `store` keeps them: exactly one prose block at the slot, or the inline surface's
+ *  text. Null where the reload would read anything else. */
+export declare function readBack(bytes: string, store: StoredAs): ReadBack | null;
+/** The bytes `read.inlines` index into. */
+export declare const readSource: (read: ReadBack) => string;
+/** What the reader sees of a read, in the content reading (live-mode.md § 2). */
+export declare function shownOf(read: ReadBack, store: StoredAs): string;
+/** Whether `line` still reads as `node`'s kind where `store` keeps it: always, on an inline
+ *  surface, which never reads its text as a block. */
+export declare function keepsKindAt(node: NodeView, line: string, store: StoredAs): boolean;