@voithos-labs/aragonite 0.10.4 → 0.10.7

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

@@ -6,6 +6,7 @@
  */
 import { assertInvariant } from '../../../assert';
 import { appendNode } from './scan-state';
+import { isHighSurrogate, isLowSurrogate } from '../../lines';
 // ── Flanking classification (§6.2 phase 1) ──────────────────────────────────
 /** Unicode punctuation (ASCII punctuation + general category P). */
 function isPunct(ch) {
@@ -28,10 +29,8 @@ function isWhitespace(ch) {
 // Flanking neighbors are read as full code points: a UTF-16 unit read would classify an
 // astral neighbor as a lone surrogate, while the spec defines the classes over code points.
 function codePointBefore(raw, pos) {
-    const unit = raw.charCodeAt(pos - 1);
-    if (unit >= 0xdc00 && unit <= 0xdfff && pos >= 2) {
-        const high = raw.charCodeAt(pos - 2);
-        if (high >= 0xd800 && high <= 0xdbff)
+    if (pos >= 2 && isLowSurrogate(raw.charCodeAt(pos - 1))) {
+        if (isHighSurrogate(raw.charCodeAt(pos - 2)))
             return raw.slice(pos - 2, pos);
     }
     return raw[pos - 1];
@@ -91,7 +90,7 @@ export function processEmphasis(ctx, floor) {
     const win = openNodeWindow(ctx, delimiters[floor].node);
     const slotOf = mapDelimiterSlots(win, delimiters, floor, top);
     if (slotOf === null) {
-        // Warn rather than throw: the state is unreachable today, and a false positive must not
+        // Warn rather than throw: the state should be unreachable, and a false positive must not
         // take a real editor's block to the fallback. The runs left behind stay literal text.
         assertInvariant('emphasis-run-node-live', () => ({
             code: 'emphasis-run-node-missing',
@@ -166,14 +165,14 @@ export function processEmphasis(ctx, floor) {
     delimiters.length = floor;
 }
 const CHAR_BUCKET = { '*': 0, _: 6, '~': 12 };
-/** §6.2 multiple-of-3 rule, on ORIGINAL run lengths (commonmark.js `origdelims`). */
+/** §6.2 multiple-of-3 rule, on the original run lengths (commonmark.js `origdelims`). */
 function isOddMatch(opener, closer) {
     return ((closer.canOpen || opener.canClose) &&
         closer.origLength % 3 !== 0 &&
         (opener.origLength + closer.origLength) % 3 === 0);
 }
 /**
- * cmark-gfm pairs strikethrough runs only at equal length. A gate of its own: the multiple-of-3
+ * cmark-gfm pairs strikethrough runs only at equal length. A check of its own: the multiple-of-3
  * rule misses the flanking-pure `~a~~` / `~~a~` shapes, and `*`/`_` carry no such rule.
  */
 function tildeLengthsAgree(opener, closer) {
@@ -182,8 +181,8 @@ function tildeLengthsAgree(opener, closer) {
 function wrapMatch(win, raw, opener, closer, openerSlot, closerSlot) {
     const use = opener.length >= 2 && closer.length >= 2 ? 2 : 1;
     const kind = opener.char === '~' ? 'strikethrough' : use === 2 ? 'strong' : 'emphasis';
-    // The NONE arm only bounds this walk. What rules out cycling the list closeNodeWindow walks
-    // is the caller's contract (slots ascend with scan order, relinks skip forward), not this arm.
+    // The `NONE` branch only bounds this walk. What rules out cycling the list `closeNodeWindow`
+    // walks is the caller's contract (slots ascend with scan order, relinks skip forward).
     const children = [];
     for (let i = win.next[openerSlot]; i !== closerSlot && i !== NONE; i = win.next[i]) {
         children.push(win.slot[i]);
@@ -255,11 +254,8 @@ function insertNodeAfter(win, at, node) {
     if (after !== NONE)
         win.prev[after] = i;
 }
-/**
- * Delimiters and their run nodes are both in scan order, so one merge walk places them all.
- * Null when a run node is missing: the pass's precondition broke upstream, and the caller must
- * drop the pass rather than walk off a linked list that has no end.
- */
+/** Delimiters and their run nodes share scan order, so one merge walk places them all. Null when
+ *  a run node is missing: the caller must drop the pass rather than walk a list with no end. */
 function mapDelimiterSlots(win, delimiters, floor, top) {
     const slotOf = new Array(top);
     let s = 0;

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

@@ -4,4 +4,6 @@
  */
 import { type InlineNode } from '../../nodes';
 import type { LinkReferenceResolver } from '../link-reference-resolver';
-export declare function scanInline(raw: string, start: number, end: number, resolver?: LinkReferenceResolver): InlineNode[];
+import type { GrammarView } from '../../../schema/block-openers';
+/** `grammar` is the editor's: a handler whose plugin it leaves out never runs, so its bytes stay text. */
+export declare function scanInline(raw: string, start: number, end: number, resolver: LinkReferenceResolver | undefined, grammar: GrammarView): InlineNode[];

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

@@ -3,6 +3,7 @@
  * from ../index.ts. Contract: InlineNode[] with absolute offsets into raw, covering [start, end).
  */
 import { isBuiltinInlineKind } from '../../nodes';
+import { resolvesIn } from '../../../schema/plugin-activation';
 import { inlineDescendants } from '../walk';
 import { handleAngle, scanGfmAutolinks } from './autolinks';
 import { handleBang, handleCloseBracket, handleOpenBracket } from './brackets';
@@ -11,25 +12,26 @@ import { handleDelimiter, processEmphasis } from './emphasis';
 import { appendNode, createScanContext, flushPendingText, mergeAdjacentText } from './scan-state';
 import { handleAmpersand, handleBackslash, handleNewline } from './simple-nodes';
 import { getPrefixRungs, getUnreservedRungs, hasInlineSyntax, hasPrefixRungs, hasScanProbeRungs, isScanProbeTrigger } from './plugin-syntax';
-// Every character that can start a construct or anchor a lookback: the dispatch cases below
-// plus `@` (GFM email lookback). `!` and `]` are deliberately absent, mattering only in ranges
-// that also contain `[`; a plugin rung makes `!` visible per registration (plugin-syntax.ts).
-const SPECIAL_CHARS = '\\`&\n<[*_~@';
-// GFM bare http/www autolinks contain no character from the set above, so their starts get
-// conditional probes: `:` counts only when `//` follows, `w`/`W` only on a `www.` prefix. The
-// lookahead may read past `end` and over-trigger, which costs one wasted scan, never a node.
+import { BUILTIN_TRIGGERS } from './triggers';
+// Every character that always sends a range through the scan loop: the built-in triggers the
+// table marks `always`, plus `@`, which anchors the GFM email lookback without a handler.
+const SPECIAL = new Uint8Array(128);
+for (const [char, { scanned }] of BUILTIN_TRIGGERS) {
+    if (scanned === 'always')
+        SPECIAL[char.charCodeAt(0)] = 1;
+}
+SPECIAL[0x40] = 1; // @
+// Bare http/www autolinks hold no character above, so `:` counts only before `//` and `w`/`W`
+// only on `www.`; a lookahead past `end` costs one wasted scan, never a node.
 const PROBE_SCHEME = 2;
 const PROBE_WWW = 3;
-const SPECIAL = new Uint8Array(128);
-for (let i = 0; i < SPECIAL_CHARS.length; i++)
-    SPECIAL[SPECIAL_CHARS.charCodeAt(i)] = 1;
 SPECIAL[0x3a] = PROBE_SCHEME; // :
 SPECIAL[0x57] = PROBE_WWW; // W
 SPECIAL[0x77] = PROBE_WWW; // w
 /** Fast bail for the per-keystroke hot path: plain prose skips the scan loop. */
 function needsScan(raw, start, end) {
-    // Registered plugin triggers are held out of SPECIAL_CHARS, so probe them only when
-    // something is registered; an unregistered scan pays one always-false test per character.
+    // Registered plugin triggers are held out of SPECIAL, so check them only when something
+    // is registered; an unregistered scan pays one always-false test per character.
     const probePlugins = hasScanProbeRungs();
     for (let i = start; i < end; i++) {
         const code = raw.charCodeAt(i);
@@ -64,17 +66,16 @@ function needsScan(raw, start, end) {
     }
     return false;
 }
-// Try a trigger's rungs in dispatch order: the first whose prefix matches at `ctx.pos` and whose
-// recognizer claims wins. Claim validation lives here once, on both dispatch paths, and sits past
-// the decline so a declining rung pays none of it and leaves `ctx` byte-identical.
-function tryRungs(ctx, rungs) {
+// The first handler whose prefix matches at `ctx.pos`, whose plugin this editor lists and whose
+// recognizer returns a node wins; that node is checked here, once for both dispatch paths.
+function tryRungs(ctx, rungs, grammar) {
     if (!rungs)
         return null;
     const { raw, pos, end } = ctx;
     for (const rung of rungs) {
-        if (!raw.startsWith(rung.prefix, pos))
+        if (!raw.startsWith(rung.prefix, pos) || !resolvesIn(grammar.activation, rung.owner))
             continue;
-        const node = rung.recognizer(raw, pos, end);
+        const node = rung.recognizer(raw, pos, end, grammar);
         if (!node)
             continue;
         if (node.start !== pos) {
@@ -83,48 +84,46 @@ function tryRungs(ctx, rungs) {
         if (node.end <= pos) {
             throw new Error(`inline-syntax "${rung.prefix}" did not advance`);
         }
-        // A block's scan range is not always its raw (a heading's excludes the closing `#` run, a
-        // table cell's the `|`), so a recognizer searching the STRING claims bytes the block still
-        // needs, and the overrun leaves no trace beyond wrong caret offsets. Half-open: ending AT
-        // `end` is ordinary, only past it is a fault.
+        // A block's scan range is not always its whole raw (a setext heading's stops before its
+        // underline), so a recognizer that reads past `end` takes bytes the block still needs.
         if (node.end > end) {
             throw new Error(`inline-syntax "${rung.prefix}" claimed [${node.start}, ${node.end}), past the scan ` +
-                `range end ${end} — a recognizer must bound its search by the \`end\` it is given`);
+                `range end ${end}: a recognizer must bound its search by the \`end\` it is given`);
         }
         stampClaim(node, rung);
         return node;
     }
     return null;
 }
-// A rung minting a BUILT-IN kind borrows the editor's model for bytes of its own, and the
-// editor's inverse emits built-in grammar, so an image minted over `![[cat.png]]` would resize
-// into GFM and take the author's syntax with it. Descendants stamp on the same rule; a rung's
-// own kind needs no stamp. Assigned, never merged, so a recognizer cannot name its own claimer.
+// A built-in node a plugin handler created (an `image` over `![[cat.png]]`) is marked with that
+// handler, so the editor's writers re-serialize it in the plugin's syntax rather than GFM.
 function stampClaim(node, claim) {
     for (const inline of inlineDescendants([node])) {
         if (isBuiltinInlineKind(inline.kind))
             inline.syntaxClaim = claim;
     }
 }
-export function scanInline(raw, start, end, resolver) {
+/** `grammar` is the editor's: a handler whose plugin it leaves out never runs, so its bytes stay text. */
+export function scanInline(raw, start, end, resolver, grammar) {
     if (start >= end)
         return [];
     if (!needsScan(raw, start, end)) {
         return [{ kind: 'text', start, end, text: raw.slice(start, end) }];
     }
     const ctx = createScanContext(raw, start, end, resolver);
-    // Reserved-trigger prefix rungs are consulted before the switch so they can outrank a
-    // built-in case: a handler consumes its trigger and advances (`handleBang` eats `![` whole),
-    // so the scan never returns to a position the switch has read. Hoisted for the empty registry.
+    // Plugin handlers on a built-in trigger run before the switch, whose handler consumes the
+    // trigger (`handleBang` eats `![` whole); hoisted so an empty registry costs nothing.
     const consultPrefixRungs = hasPrefixRungs();
     while (ctx.pos < ctx.end) {
         if (consultPrefixRungs) {
-            const node = tryRungs(ctx, getPrefixRungs(raw[ctx.pos]));
+            const node = tryRungs(ctx, getPrefixRungs(raw[ctx.pos]), grammar);
             if (node) {
                 appendNode(ctx, node);
                 continue;
             }
         }
+        // A switch with direct calls, not a lookup in the trigger table: an indirect call per
+        // trigger measured slower. A test holds the cases equal to the table's rows.
         switch (raw[ctx.pos]) {
             case '\\':
                 handleBackslash(ctx);
@@ -157,7 +156,7 @@ export function scanInline(raw, start, end, resolver) {
                 break;
             default: {
                 if (hasInlineSyntax()) {
-                    const node = tryRungs(ctx, getUnreservedRungs(raw[ctx.pos]));
+                    const node = tryRungs(ctx, getUnreservedRungs(raw[ctx.pos]), grammar);
                     if (node) {
                         appendNode(ctx, node);
                         break;

package/dist/core/inline/scan/plugin-syntax.d.ts

@@ -1,10 +1,11 @@
 /**
- * Unstable-public hook for plugin inline syntax: a priority ladder mirroring `OPENER_PRIORITIES`.
- * One trigger character plus an optional prefix beginning with it, dispatched low-priority-first
- * so a plugin can outrank a built-in trigger on a longer prefix (footnotes' `[^` beating `[`).
- * Reserved triggers hold pre-switch rungs, all others hold `default`-arm rungs (scan/index.ts).
+ * Registry for plugin inline syntax: a trigger character plus an optional prefix beginning with
+ * it, tried lowest priority first (numbered as `OPENER_PRIORITIES`), so a longer prefix can outrank
+ * a built-in trigger (footnotes' `[^` beating `[`). An `InlineRung` is one handler. A reserved
+ * trigger is one the scanner handles itself (./triggers.ts); its plugin handlers run first.
  */
 import type { ImageSyntaxRewriter, InlineNode, InlineSyntaxClaim } from '../../nodes';
+import type { GrammarView } from '../../../schema/block-openers';
 /**
  * Inspect `raw` at `pos` (the trigger) within `[pos, end)`. Return a node with `start === pos`
  * and `pos < node.end <= end` to claim that span (`node.end` is the scan advance), or `null` to
@@ -12,59 +13,50 @@ import type { ImageSyntaxRewriter, InlineNode, InlineSyntaxClaim } from '../../n
  * range may be a slice of it, so a terminator past `end` must decline. Claiming past it throws.
  */
 export type InlineSyntaxRecognizer = (raw: string, pos: number, end: number) => InlineNode | null;
-/** The priority ladder every registration prices against; lower is consulted first. */
+/** The priority numbers registrations use; lower is consulted first. */
 export declare const INLINE_PRIORITIES: {
-    /** Rungs consulted before a reserved trigger's built-in handling. */
+    /** Handlers consulted before a reserved trigger's built-in handling. */
     readonly prefixOverride: 40;
-    /** The switch's own anchor; not registerable. */
+    /** The built-in handler's own place in the order; not registerable. */
     readonly builtin: 50;
-    /** Default rung for bare-trigger registrations. */
+    /** Default for bare-trigger registrations. */
     readonly plugin: 100;
 };
 export interface InlineSyntaxOptions {
-    /**
-     * Multi-char prefix beginning with the trigger; required for a reserved trigger. Consulted
-     * ahead of the built-in case, so a prefix that also opens a built-in construct outranks it
-     * and the recognizer must decline the overlap itself. Getting that wrong is silent; see the
-     * plugin guide's reserved-trigger section.
-     */
+    /** Two or more characters starting with the trigger; required for a reserved trigger, where it
+     *  runs before the built-in handler, so decline a built-in construct it also opens. */
     prefix?: string;
-    /** Rung; lower is consulted first. Defaults to `INLINE_PRIORITIES.plugin`. */
+    /** Lower is consulted first. Defaults to `INLINE_PRIORITIES.plugin`. */
     priority?: number;
-    /**
-     * Re-serializer for the built-in `image` nodes this recognizer mints; without it the editor
-     * declines those edits rather than writing GFM over the claimed bytes. Return `null` for
-     * anything your grammar cannot hold: source-identical bytes are dropped silently by the
-     * commit's equality guard. See the plugin guide's inline section.
-     */
+    /** Re-serializes the `image` nodes this recognizer creates; without it the editor refuses
+     *  their edits rather than write GFM over your syntax. Return `null` for what it can't hold. */
     rewriteImage?: ImageSyntaxRewriter;
-    /**
-     * The trigger is a symmetric one-byte delimiter (`$…$`) a keystroke should close at once:
-     * typing it lands its twin after the caret, so the new opener pairs with that twin rather
-     * than with a later formula's delimiter (see `delimiter-autopair.ts`). Bare triggers only.
-     */
+    /** Typing the trigger (`$…$`) inserts its closer after the caret, so the opener pairs with it
+     *  rather than a later formula's delimiter (`delimiter-autopair.ts`). Bare triggers only. */
     autoPair?: boolean;
 }
+/** The scan hands its grammar on as a fourth argument, which only the core text directive reads. */
+type ScopedRecognizer = (raw: string, pos: number, end: number, grammar: GrammarView) => InlineNode | null;
 export interface InlineRung extends InlineSyntaxClaim {
-    recognizer: InlineSyntaxRecognizer;
+    recognizer: ScopedRecognizer;
     priority: number;
+    /** The plugin whose setup registered the handler; null for a core one. */
+    owner: string | null;
 }
 export declare function registerInlineSyntax(trigger: string, recognizer: InlineSyntaxRecognizer, options?: InlineSyntaxOptions): void;
-/**
- * Whether the built-in scanner claims `trigger` through a `case` arm. A rung on one is consulted
- * BEFORE that arm, so it owes the overlap a decline; the conformance kit refuses it an exemption.
- */
+/** Whether the built-in scanner handles `trigger` itself. A plugin handler on one runs before the
+ *  built-in handler, so it must decline the overlap itself. */
 export declare function isReservedInlineTrigger(trigger: string): boolean;
-/** Rungs for a trigger in dispatch order, reserved-aware. Empty when none. */
+/** The handlers for a trigger in dispatch order, from whichever map holds it. Empty when none. */
 export declare function getInlineRungs(trigger: string): readonly InlineRung[];
 export declare function getUnreservedRungs(char: string): InlineRung[] | undefined;
 export declare function getPrefixRungs(char: string): InlineRung[] | undefined;
 export declare function hasInlineSyntax(): boolean;
-/** Read once per scan, so an empty set leaves `needsScan` at its pre-plugin cost. */
+/** Read once per scan, so with no probed trigger `needsScan` pays nothing extra per character. */
 export declare function hasScanProbeRungs(): boolean;
 export declare function isScanProbeTrigger(char: string): boolean;
-/** Whether a plugin asked for `char` to close itself as it is typed. */
-export declare function isAutoPairTrigger(char: string): boolean;
+/** Whether any plugin the editor's grammar lists asked for `char` to close itself as it is typed. */
+export declare function isAutoPairTrigger(char: string, grammar: GrammarView): boolean;
 /** False costs the scan loop nothing. */
 export declare function hasPrefixRungs(): boolean;
-export declare function __resetInlineSyntaxForTests(): void;
+export {};

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

@@ -1,46 +1,37 @@
 /**
- * Unstable-public hook for plugin inline syntax: a priority ladder mirroring `OPENER_PRIORITIES`.
- * One trigger character plus an optional prefix beginning with it, dispatched low-priority-first
- * so a plugin can outrank a built-in trigger on a longer prefix (footnotes' `[^` beating `[`).
- * Reserved triggers hold pre-switch rungs, all others hold `default`-arm rungs (scan/index.ts).
+ * Registry for plugin inline syntax: a trigger character plus an optional prefix beginning with
+ * it, tried lowest priority first (numbered as `OPENER_PRIORITIES`), so a longer prefix can outrank
+ * a built-in trigger (footnotes' `[^` beating `[`). An `InlineRung` is one handler. A reserved
+ * trigger is one the scanner handles itself (./triggers.ts); its plugin handlers run first.
  */
-import { registerOnce } from '../../../schema/register-once';
-/** The priority ladder every registration prices against; lower is consulted first. */
+import { resolvesIn } from '../../../schema/plugin-activation';
+import { createPluginRegistry } from '../../../schema/plugin-registry';
+import { BUILTIN_TRIGGERS } from './triggers';
+/** The priority numbers registrations use; lower is consulted first. */
 export const INLINE_PRIORITIES = {
-    /** Rungs consulted before a reserved trigger's built-in handling. */
+    /** Handlers consulted before a reserved trigger's built-in handling. */
     prefixOverride: 40,
-    /** The switch's own anchor; not registerable. */
+    /** The built-in handler's own place in the order; not registerable. */
     builtin: 50,
-    /** Default rung for bare-trigger registrations. */
+    /** Default for bare-trigger registrations. */
     plugin: 100
 };
-/**
- * The characters `scanInline`'s switch claims. A bare registration on one would never fire; it
- * needs a prefix rung priced below `builtin`. Kept in step with `./index.ts` by G4.18.
- */
-const BUILTIN_TRIGGERS = new Set(['\\', '`', '&', '\n', '*', '_', '~', '[', ']', '!', '<']);
-/**
- * Reserved triggers a registration makes visible to `needsScan` (scan/index.ts) instead, probed
- * only while a rung lives on them. `!` is here rather than in `SPECIAL_CHARS` because making it
- * unconditionally special would drag every prose `"Hello!"` through the full scan loop.
- */
-const SCAN_PROBED_RESERVED = new Set(['!']);
-/**
- * Reserved triggers with no route to the scan at all, so a prefix rung on one would be accepted
- * yet never consulted: the silent no-op this seam exists to prevent. A construct needing `]`
- * gives it a route first. Pinned against a SPECIAL_CHARS edit by G4.18.
- */
-const REJECTED_RESERVED = new Set([']']);
 const NO_RUNGS = [];
-// Reserved-trigger prefix rungs (pre-switch) live apart from every other trigger's rungs
-// (`default` arm) so each dispatch path reads one map and its empty gate is one `size` check.
+// One entry per (trigger, prefix, priority); the dispatch maps below are derived from it.
+const handlers = createPluginRegistry({
+    label: 'registerInlineSyntax',
+    isBuiltin: () => false,
+    onChange: rebuildDispatch
+});
+// Reserved and unreserved handlers are consulted at different points of the scan, so each
+// point reads one map and its empty check is one `size` read.
 const reservedRegistry = new Map();
 const unreservedRegistry = new Map();
-// Triggers whose keystroke closes itself (`autoPair`); the built-in backtick is not registered
-// here, the typing seam knows it on its own.
-const autoPairTriggers = new Set();
-// Triggers the fast bail (`needsScan`, scan/index.ts) must visit while a rung lives on them.
-// Maintained at registration, so a rung on a trigger `SPECIAL_CHARS` already visits costs nothing.
+// Triggers that close themselves as they are typed (`autoPair`), each with every plugin that asked
+// (null for a registration outside a plugin); the built-in backtick is not here.
+const autoPairTriggers = new Map();
+// Triggers the fast bail (`needsScan`, scan/index.ts) checks only while a plugin handler is
+// registered on them; a trigger it always checks is never added.
 const scanProbeTriggers = new Set();
 // ── Registration ───────────────────────────────────────────────────────────────
 export function registerInlineSyntax(trigger, recognizer, options) {
@@ -52,19 +43,19 @@ export function registerInlineSyntax(trigger, recognizer, options) {
         throw new Error(`registerInlineSyntax: prefix ${JSON.stringify(prefix)} must begin with the trigger ` +
             `${JSON.stringify(trigger)} and be at least two characters`);
     }
-    const reserved = BUILTIN_TRIGGERS.has(trigger);
-    if (reserved) {
-        // Pinned contract: keep the message verbatim. A reserved trigger is reachable only
-        // through a prefix rung priced below the switch anchor.
+    const builtin = BUILTIN_TRIGGERS.get(trigger);
+    if (builtin) {
+        // A test pins this message verbatim. A reserved trigger is reachable only through a
+        // prefix with a priority below `builtin`.
         if (prefix === undefined) {
             throw new Error(`registerInlineSyntax: ${JSON.stringify(trigger)} is claimed by the built-in scanner, ` +
-                `which dispatches it before the plugin registry — the recognizer would never fire`);
+                `which dispatches it before the plugin registry; the recognizer would never fire`);
         }
-        if (REJECTED_RESERVED.has(trigger)) {
+        if (builtin.scanned === 'never') {
             throw new Error(`registerInlineSyntax: reserved trigger ${JSON.stringify(trigger)} is skipped by the ` +
-                `scanner's fast bail (absent from SPECIAL_CHARS in scan/index.ts; it matters only ` +
-                `inside "["-bearing ranges), so a prefix rung on it would never fire in plain text — ` +
-                `make the trigger scan-visible or scan-probed before registering`);
+                `scanner's fast bail (it matters only inside "["-bearing ranges), so a prefix ` +
+                `inline syntax handler on it would never fire in plain text; make the trigger ` +
+                `scan-visible or scan-probed in scan/triggers.ts before registering`);
         }
         if (priority >= INLINE_PRIORITIES.builtin) {
             throw new Error(`registerInlineSyntax: reserved trigger ${JSON.stringify(trigger)} needs a priority ` +
@@ -77,26 +68,38 @@ export function registerInlineSyntax(trigger, recognizer, options) {
             `itself, so it cannot be combined with a prefix`);
     }
     const effectivePrefix = prefix ?? trigger;
-    const registry = reserved ? reservedRegistry : unreservedRegistry;
-    const existing = registry.get(trigger);
-    const isDuplicate = existing?.some((r) => r.prefix === effectivePrefix && r.priority === priority) ?? false;
-    registerOnce(isDuplicate, () => {
-        upsertRung(registry, trigger, {
-            recognizer,
-            prefix: effectivePrefix,
-            priority,
-            rewriteImage
-        });
-        // A rung on a trigger the fast bail would skip must make the scan visit it,
-        // or the recognizer is the silent no-op this seam refuses to accept.
-        if (!reserved || SCAN_PROBED_RESERVED.has(trigger))
-            scanProbeTriggers.add(trigger);
-        if (autoPair)
-            autoPairTriggers.add(trigger);
+    handlers.register(JSON.stringify([trigger, effectivePrefix, priority]), {
+        trigger,
+        recognizer,
+        prefix: effectivePrefix,
+        priority,
+        rewriteImage,
+        autoPair: autoPair ?? false
     }, `registerInlineSyntax: ${JSON.stringify(trigger)} already registered at prefix ` +
         `${JSON.stringify(effectivePrefix)}, priority ${priority}`);
 }
-// Kept sorted at insert so dispatch order does not depend on registration order.
+function rebuildDispatch() {
+    reservedRegistry.clear();
+    unreservedRegistry.clear();
+    autoPairTriggers.clear();
+    scanProbeTriggers.clear();
+    for (const { value, owner } of handlers.records()) {
+        const { trigger, autoPair, ...rung } = value;
+        const builtin = BUILTIN_TRIGGERS.get(trigger);
+        const registry = builtin ? reservedRegistry : unreservedRegistry;
+        registry.set(trigger, [...(registry.get(trigger) ?? []), { ...rung, owner }]);
+        // A handler on a trigger the fast bail would skip must make the scan check it, or the
+        // recognizer is the silent no-op this registry refuses to accept.
+        if (!builtin || builtin.scanned === 'when-registered')
+            scanProbeTriggers.add(trigger);
+        if (autoPair)
+            autoPairTriggers.set(trigger, (autoPairTriggers.get(trigger) ?? new Set()).add(owner));
+    }
+    for (const rungs of [...reservedRegistry.values(), ...unreservedRegistry.values()]) {
+        rungs.sort(compareRungs);
+    }
+}
+// Dispatch order is sorted, so it does not depend on registration order.
 function compareRungs(a, b) {
     if (a.priority !== b.priority)
         return a.priority - b.priority;
@@ -104,30 +107,13 @@ function compareRungs(a, b) {
         return b.prefix.length - a.prefix.length;
     return a.prefix < b.prefix ? -1 : a.prefix > b.prefix ? 1 : 0;
 }
-// Overwriting a matching (prefix, priority) rung is the dev-server replace path.
-function upsertRung(registry, trigger, rung) {
-    const rungs = registry.get(trigger);
-    if (!rungs) {
-        registry.set(trigger, [rung]);
-        return;
-    }
-    const at = rungs.findIndex((r) => r.prefix === rung.prefix && r.priority === rung.priority);
-    if (at >= 0)
-        rungs[at] = rung;
-    else {
-        rungs.push(rung);
-        rungs.sort(compareRungs);
-    }
-}
 // ── Dispatch accessors ───────────────────────────────────────────────────────────
-/**
- * Whether the built-in scanner claims `trigger` through a `case` arm. A rung on one is consulted
- * BEFORE that arm, so it owes the overlap a decline; the conformance kit refuses it an exemption.
- */
+/** Whether the built-in scanner handles `trigger` itself. A plugin handler on one runs before the
+ *  built-in handler, so it must decline the overlap itself. */
 export function isReservedInlineTrigger(trigger) {
     return BUILTIN_TRIGGERS.has(trigger);
 }
-/** Rungs for a trigger in dispatch order, reserved-aware. Empty when none. */
+/** The handlers for a trigger in dispatch order, from whichever map holds it. Empty when none. */
 export function getInlineRungs(trigger) {
     const registry = BUILTIN_TRIGGERS.has(trigger) ? reservedRegistry : unreservedRegistry;
     return registry.get(trigger) ?? NO_RUNGS;
@@ -141,24 +127,24 @@ export function getPrefixRungs(char) {
 export function hasInlineSyntax() {
     return unreservedRegistry.size > 0;
 }
-/** Read once per scan, so an empty set leaves `needsScan` at its pre-plugin cost. */
+/** Read once per scan, so with no probed trigger `needsScan` pays nothing extra per character. */
 export function hasScanProbeRungs() {
     return scanProbeTriggers.size > 0;
 }
 export function isScanProbeTrigger(char) {
     return scanProbeTriggers.has(char);
 }
-/** Whether a plugin asked for `char` to close itself as it is typed. */
-export function isAutoPairTrigger(char) {
-    return autoPairTriggers.has(char);
+/** Whether any plugin the editor's grammar lists asked for `char` to close itself as it is typed. */
+export function isAutoPairTrigger(char, grammar) {
+    const owners = autoPairTriggers.get(char);
+    if (!owners)
+        return false;
+    for (const owner of owners)
+        if (resolvesIn(grammar.activation, owner))
+            return true;
+    return false;
 }
 /** False costs the scan loop nothing. */
 export function hasPrefixRungs() {
     return reservedRegistry.size > 0;
 }
-export function __resetInlineSyntaxForTests() {
-    reservedRegistry.clear();
-    unreservedRegistry.clear();
-    scanProbeTriggers.clear();
-    autoPairTriggers.clear();
-}

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

@@ -8,6 +8,8 @@ import type { BacktickRunIndex } from '../backticks';
 import type { LinkReferenceResolver } from '../link-reference-resolver';
 export interface ScanContext {
     raw: string;
+    /** Where the scan range begins, which GFM's autolink boundary treats as a line start. */
+    start: number;
     pos: number;
     end: number;
     /** Working list, flat, offset-ordered; emphasis wraps later. */

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

@@ -6,6 +6,7 @@
 export function createScanContext(raw, start, end, resolver) {
     return {
         raw,
+        start,
         pos: start,
         end,
         nodes: [],

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

@@ -6,9 +6,6 @@
 import { type ScanContext } from './scan-state';
 export declare function handleBackslash(ctx: ScanContext): void;
 export declare function handleAmpersand(ctx: ScanContext): void;
-/**
- * §6.7 trailing-spaces form: two-plus spaces before the newline become a hardLineBreak covering
- * spaces + newline; one space is a softbreak. Lookback is clamped to the pending text run, so
- * spaces inside an already-consumed node cannot count.
- */
+/** §6.7: two or more spaces before the newline make a hard break covering them and the newline.
+ *  The lookback stops at the pending text run, so spaces inside an earlier node never count. */
 export declare function handleNewline(ctx: ScanContext): void;

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

@@ -29,11 +29,8 @@ export function handleAmpersand(ctx) {
     else
         ctx.pos++;
 }
-/**
- * §6.7 trailing-spaces form: two-plus spaces before the newline become a hardLineBreak covering
- * spaces + newline; one space is a softbreak. Lookback is clamped to the pending text run, so
- * spaces inside an already-consumed node cannot count.
- */
+/** §6.7: two or more spaces before the newline make a hard break covering them and the newline.
+ *  The lookback stops at the pending text run, so spaces inside an earlier node never count. */
 export function handleNewline(ctx) {
     const { raw, pos, textStart } = ctx;
     let i = pos - 1;

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

@@ -0,0 +1,17 @@
+/**
+ * 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 type { ScanContext } from './scan-state';
+/**
+ * When the fast bail looks for a trigger: `always`; `when-registered`, only while a plugin
+ * handler is registered on it; or `never`, which also refuses a plugin handler on it.
+ */
+export type TriggerScan = 'always' | 'when-registered' | 'never';
+export interface BuiltinTrigger {
+    handler: (ctx: ScanContext) => void;
+    scanned: TriggerScan;
+}
+export declare const BUILTIN_TRIGGERS: ReadonlyMap<string, BuiltinTrigger>;