@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/components/paste-image-arm.js

@@ -1,9 +1,7 @@
 /**
- * The host image-import arm of a paste, shared by the editable-surface clipboard skeleton and the
- * editor-root fallback. It ends at "here is the markdown nobody claimed"; each caller owns what
- * happens next. Two ordering rules: files are read before the first await (`clipboardData` is not
- * dependably live afterwards), and a multi-block selection reaches the delete only after the hook
- * answers, so a failed import destroys nothing.
+ * Hands a paste's images to the host's import hook, for the blocks' clipboard code and the
+ * editor-root fallback alike. Files are read before the first await, since `clipboardData` may
+ * not stay live, and a multi-block selection is deleted only after the hook answers.
  */
 import { emitClipboardError } from '../editor-events';
 export function createImagePasteArm(deps) {
@@ -14,13 +12,12 @@ export function createImagePasteArm(deps) {
             if (!importImage)
                 return null;
             const markdown = await importAll(deps, importImage, files);
-            // Empty markdown ends the arm like no markdown, and keeps the seam's payload
-            // below non-empty.
+            // Empty markdown ends this the same way no markdown does, and keeps the
+            // cross-block paste from being handed an empty string.
             if (!markdown)
                 return null;
-            // Inherit the ordinary paste route rather than placing anything here: the
-            // delete collapses start-wins and the receiving block may be merged away. The
-            // seam reads `isCrossBlock` LIVE, so a mid-import selection is the one replaced.
+            // The ordinary paste route, which reads `isCrossBlock` live, since the delete can
+            // collapse or merge away the receiving block.
             if (await deps.crossBlock.handlePaste(e, markdown))
                 return null;
             return markdown;
@@ -33,11 +30,8 @@ export function createImagePasteArm(deps) {
 function imageFilesOf(data) {
     return Array.from(data?.files ?? []).filter((file) => file.type.startsWith('image/'));
 }
-/**
- * One insertion, not one per image: a hook may return multi-line markdown, whose
- * structural paste can split the block out from under a second insertion addressed at
- * anchor + length — and one paste gesture owes the user one undo entry.
- */
+/** One insertion for every image: multi-line markdown can split the block out from under a
+ *  second insertion, and one paste is one undo entry. */
 async function importAll(deps, importImage, files) {
     const markdown = [];
     for (const image of files) {
@@ -51,9 +45,8 @@ async function importAll(deps, importImage, files) {
                 markdown.push(inserted);
         }
         catch (error) {
-            // One failed import skips its image; the rest of the paste still lands. Still
-            // a clipboard failure, not a command throw: the host needs to know an asset
-            // it started importing will not appear in the document.
+            // A failed import skips its image and reports a clipboard error, so the host knows
+            // that asset will not appear.
             emitClipboardError(deps.events, { error });
         }
     }

package/dist/components/portal.d.ts

@@ -3,9 +3,6 @@
  * instance: the node keeps its identity, its Svelte scope classes and its place in the
  * reactive tree, so only its position in the DOM moves.
  */
-/**
- * Attachment factory: appends the node to `target`, and puts it back where it was when the
- * target changes or the attachment tears down. A null target leaves the node home, which is
- * how the seam stays absent by default.
- */
+/** Appends the node to `target` and puts it back when the target changes or the attachment
+ *  tears down; a null target leaves the node where it is. */
 export declare function portalInto(target: HTMLElement | null | undefined): (node: HTMLElement) => (() => void) | void;

package/dist/components/portal.js

@@ -3,17 +3,14 @@
  * instance: the node keeps its identity, its Svelte scope classes and its place in the
  * reactive tree, so only its position in the DOM moves.
  */
-/**
- * Attachment factory: appends the node to `target`, and puts it back where it was when the
- * target changes or the attachment tears down. A null target leaves the node home, which is
- * how the seam stays absent by default.
- */
+/** Appends the node to `target` and puts it back when the target changes or the attachment
+ *  tears down; a null target leaves the node where it is. */
 export function portalInto(target) {
     return (node) => {
         if (!target)
             return;
-        // A marker holds the home position: the siblings around it can change while the node
-        // is away, so a captured `nextSibling` would insert against a stale reference.
+        // A comment marks where the node came from: the siblings around it can change while
+        // the node is away, so a captured `nextSibling` would be a stale reference.
         const marker = node.ownerDocument.createComment('');
         node.parentNode?.insertBefore(marker, node);
         target.appendChild(node);

package/dist/core/directive/activate.d.ts

@@ -1,8 +1,7 @@
 /**
- * Grammar-side activation for the `:::name` directive primitive. No components: core must not
- * reach the component tree, so the public `activateDirectives` layers render on top of this.
- * Call-based, not a module-load side effect, so a consumer that never calls it leaves `:::` and
- * `:` unclaimed. Must run before the editor parses, ahead of the grammar-consumed latch (G1.17).
- * A second activation site is a no-op: every step guards on something the tier itself owns.
+ * Grammar-side activation for the `:::name` directive syntax. The public `activateDirectives`
+ * adds the components (core can't import them) and makes both belong to no plugin. A call, not an
+ * import side effect, so `:::` and `:` stay free until someone asks. Must run before the editor
+ * first parses (G1.17); calling it twice is a no-op, since every step checks its registration first.
  */
 export declare function activateDirectiveGrammar(): void;

package/dist/core/directive/activate.js

@@ -1,25 +1,24 @@
 /**
- * Grammar-side activation for the `:::name` directive primitive. No components: core must not
- * reach the component tree, so the public `activateDirectives` layers render on top of this.
- * Call-based, not a module-load side effect, so a consumer that never calls it leaves `:::` and
- * `:` unclaimed. Must run before the editor parses, ahead of the grammar-consumed latch (G1.17).
- * A second activation site is a no-op: every step guards on something the tier itself owns.
+ * Grammar-side activation for the `:::name` directive syntax. The public `activateDirectives`
+ * adds the components (core can't import them) and makes both belong to no plugin. A call, not an
+ * import side effect, so `:::` and `:` stay free until someone asks. Must run before the editor
+ * first parses (G1.17); calling it twice is a no-op, since every step checks its registration first.
  */
 import { registerDirectiveKinds, registerDirectiveTextKind, DIRECTIVE_TEXT } from './kinds';
 import { registerDirectiveOpeners } from './container-opener';
 import { declaredPluginInlineKind, isInlineKindDeclared } from '../../schema/plugin-kind';
 import { registerInlineSyntax } from '../inline/scan/plugin-syntax';
 import { recognizeTextDirective } from './text-recognizer';
+import { defaultGrammarView } from '../../schema/block-openers';
 export function activateDirectiveGrammar() {
-    // The inline rung has nothing of its own to probe, so it borrows the `directiveText` latch,
-    // read HERE before `registerDirectiveTextKind` sets it. It cannot ask whether `:` is taken:
-    // the trigger is SHARED (emoji rungs on it too), so that question answers for another plugin.
+    // The inline handler has no registration of its own to check, so it borrows the
+    // `directiveText` flag, read before it is set; the `:` trigger is shared with emoji.
     const alreadyActive = isInlineKindDeclared(DIRECTIVE_TEXT);
     registerDirectiveKinds();
     registerDirectiveOpeners();
     registerDirectiveTextKind();
     if (!alreadyActive) {
         const kind = declaredPluginInlineKind(DIRECTIVE_TEXT);
-        registerInlineSyntax(':', (raw, pos, end) => recognizeTextDirective(raw, pos, end, kind));
+        registerInlineSyntax(':', (raw, pos, end, grammar) => recognizeTextDirective(raw, pos, end, kind, grammar ?? defaultGrammarView));
     }
 }

package/dist/core/directive/container-opener.js

@@ -19,18 +19,20 @@ export function registerDirectiveOpeners() {
     const container = declaredPluginKind(DIRECTIVE_CONTAINER);
     const leaf = declaredPluginKind(DIRECTIVE_LEAF);
     registerBlockOpener(container, {
-        // Priced off the ladder, never as a bare integer, so renumbering a built-in moves this
-        // with it. A colon fence collides with no built-in matcher; it only needs the gap.
+        // Derived from the built-in priorities, never a bare integer, so renumbering a built-in
+        // moves this with it. A colon fence collides with no built-in matcher; it only needs a gap.
         priority: OPENER_PRIORITIES.blockquote + 5,
         interruptsParagraph: (line) => matchDirectiveOpener(line) !== null,
         tryOpen(ctx) {
             const fence = matchDirectiveOpener(ctx.line.text);
             if (!fence)
                 return null;
-            const lineEnding = trailingLineEnding(ctx.line.raw);
+            // A one-line leaf at the end of the source takes the source's first break, else LF.
+            const sourceEnding = (ctx.lines[0]?.lineEnding || '\n');
+            const lineEnding = trailingLineEnding(ctx.line.raw, sourceEnding);
             if (fence.tier === 'leaf') {
-                const def = resolveDirective('leaf', fence.name);
-                const factory = resolveBlockDirectiveFactory('leaf', fence.name);
+                const def = resolveDirective('leaf', fence.name, ctx.grammar);
+                const factory = resolveBlockDirectiveFactory('leaf', fence.name, ctx.grammar);
                 if (factory) {
                     const parsed = {
                         fence,
@@ -62,12 +64,13 @@ export function registerDirectiveOpeners() {
             // body stays inside this parse entry, so it inherits its scope.
             const body = parseContainerBody(bodyText, DIRECTIVE_BODY_WRAP, {
                 scope: ctx.isDocumentParse ? 'document' : 'fragment',
-                depth: ctx.depth + 1
+                depth: ctx.depth + 1,
+                grammar: ctx.grammar
             });
-            // isDirectiveCloser guarantees an all-colon line, so its length IS the colon count.
+            // isDirectiveCloser guarantees an all-colon line, so its length is the colon count.
             const closerColonCount = closerLine.text.length;
             const closerNewline = closerLine.raw.endsWith('\n');
-            const factory = resolveBlockDirectiveFactory('container', fence.name);
+            const factory = resolveBlockDirectiveFactory('container', fence.name, ctx.grammar);
             if (factory) {
                 const parsed = {
                     fence,
@@ -126,10 +129,8 @@ function closerIndex(lines) {
     closerIndexCache.set(lines, index);
     return index;
 }
-/**
- * Smallest closer-index slot at or after `from` whose count is >= `min`, or -1. Padding leaves
- * hold 0 and an opener runs at least two colons, so they never match.
- */
+/** First closer index at or after `from` with a run of at least `min` colons, or -1. Padding
+ *  leaves hold 0, and an opener runs at least two colons, so they never match. */
 function firstCloserAtLeast(index, from, min) {
     const descend = (node, lo, hi) => {
         if (hi <= from || index.maxCounts[node] < min)

package/dist/core/directive/grammar.d.ts

@@ -15,11 +15,8 @@ export interface DirectiveFence {
 }
 export declare function matchDirectiveOpener(lineText: string): DirectiveFence | null;
 export declare function isDirectiveCloser(lineText: string, openColonCount: number): boolean;
-/**
- * The colon count needed to wrap `body`: one past its longest whole-line colon run, never below
- * `minimum`. Without it a body line reproducing the terminator reads as the container's own
- * closer and ejects everything below it on reparse.
- */
+/** The colon count needed to wrap `body`: one past its longest whole-line colon run, never below
+ *  `minimum`, so no body line reads as the container's closer on reparse. */
 export declare function escalatedColonCount(body: string, minimum: number): number;
 export declare function serializeDirective(parts: {
     colonCount: number;

package/dist/core/directive/grammar.js

@@ -3,8 +3,11 @@
  * Byte round-trip is the master invariant: `serializeDirective` reproduces the opener colons,
  * the verbatim `info` (leading separator included), the body wrap, and a matched closer exactly.
  */
+import { WHITESPACE_CHARS, WHITESPACE_CLASS } from '../lines';
 import { escalateTerminatorRun } from '../terminator-escalation';
-const OPENER = /^(:{2,})([A-Za-z][A-Za-z0-9-]*)(.*)$/;
+// The `s` flag lets the info string run to the line's end over a line separator (U+2028),
+// which the line splitter keeps inside a line.
+const OPENER = /^(:{2,})([A-Za-z][A-Za-z0-9-]*)(.*)$/s;
 export function matchDirectiveOpener(lineText) {
     const match = OPENER.exec(lineText);
     if (!match)
@@ -26,11 +29,8 @@ export function isDirectiveCloser(lineText, openColonCount) {
         count++;
     return count >= openColonCount && count === lineText.length;
 }
-/**
- * The colon count needed to wrap `body`: one past its longest whole-line colon run, never below
- * `minimum`. Without it a body line reproducing the terminator reads as the container's own
- * closer and ejects everything below it on reparse.
- */
+/** The colon count needed to wrap `body`: one past its longest whole-line colon run, never below
+ *  `minimum`, so no body line reads as the container's closer on reparse. */
 export function escalatedColonCount(body, minimum) {
     // A closer line is colons end to end, so its own length IS the run.
     return escalateTerminatorRun(body, minimum, (text, required) => isDirectiveCloser(text, required) ? text.length : null);
@@ -39,18 +39,18 @@ export function escalatedColonCount(body, minimum) {
 export function serializeDirective(parts) {
     const lineEnding = parts.lineEnding ?? '\n';
     const inner = `${parts.innerPrefix}${parts.body}${parts.innerSuffix}`;
-    // Re-derived on every emit rather than latched into metadata, so two emits over the same
-    // state always agree (G1.13). `colonCount` is a floor, not a target.
+    // Escalated from the body on every emit, so the fence holds before the editor re-reads the
+    // metadata; `colonCount` is a floor, not a target.
     const colonCount = escalatedColonCount(inner, parts.colonCount);
     const opener = ':'.repeat(colonCount);
     const closer = ':'.repeat(Math.max(colonCount, parts.closerColonCount ?? colonCount));
     const closerEnd = (parts.closerNewline ?? true) ? (parts.closerLineEnding ?? lineEnding) : '';
     return `${opener}${parts.name}${parts.info}${lineEnding}${inner}${closer}${closerEnd}`;
 }
-const LABEL = /^\s*\[([^\]]*)\]/;
+const LABEL = new RegExp(`^${WHITESPACE_CLASS}*\\[([^\\]]*)\\]`);
 const BRACES = /\{([^}]*)\}/;
 // Quoted segments fold in, so `title="a b"` stays one token instead of splitting on its space.
-const ATTR_TOKEN = /(?:[^\s"]+|"[^"]*")+/g;
+const ATTR_TOKEN = new RegExp(`(?:[^${WHITESPACE_CHARS}"]+|"[^"]*")+`, 'g');
 /**
  * Opt-in `info -> structure` reader for a leading `[label]` and a `{#id .class key=val}` block.
  * One-way: there is no inverse serializer, and the verbatim `info` stays the round-trip truth.

package/dist/core/directive/kinds.d.ts

@@ -9,7 +9,7 @@ import type { ContainerBodyWrap } from '../parser';
 export declare const DIRECTIVE_CONTAINER = "directiveContainer";
 export declare const DIRECTIVE_LEAF = "directiveLeaf";
 export declare const DIRECTIVE_TEXT = "directiveText";
-/** The `:::` opener and closer bracket every directive body, whatever kind the name mints. */
+/** The `:::` opener and closer bracket every directive body, whatever kind the name maps to. */
 export declare const DIRECTIVE_BODY_WRAP: ContainerBodyWrap;
 /** Fence bytes a container node round-trips through `rebuildDirectiveContainerRaw`. */
 export interface DirectiveContainerMetadata {
@@ -18,14 +18,11 @@ export interface DirectiveContainerMetadata {
     info: string;
     closerColonCount: number;
     closerNewline: boolean;
-    /** Authored line ending for the opener and closer chrome lines. */
+    /** Authored line ending for the opener and closer fence lines. */
     lineEnding: string;
 }
 export declare function registerDirectiveKinds(): void;
-/**
- * The `:` recognizer (text-recognizer.ts) stamps this kind on the span it delimits. The widget
- * opts into `revealSource`, so focus swaps the island for editable source and blur/Enter commits
- * (the shared reveal primitive in widget-interaction.ts). Idempotent for HMR.
- */
+/** The `:` recognizer gives this kind to the span it delimits. The widget opts into `revealSource`,
+ *  so focus swaps it for its editable source. Idempotent for HMR. */
 export declare function registerDirectiveTextKind(): void;
 export declare function rebuildDirectiveContainerRaw(node: CstNode): void;

package/dist/core/directive/kinds.js

@@ -8,14 +8,14 @@ import { declarePluginKind, declarePluginInlineKind, isInlineKindDeclared } from
 import { registerBlockKind, isBlockKindRegistered } from '../../schema/block-kind-descriptor';
 import { containerClosure } from '../../schema/closure';
 import { getPluginMetadata } from '../nodes';
-import { displayLength, trimTrailingLineEnding, trailingLineEnding } from '../lines';
+import { displayLength, ownTrailingLineEnding, trimTrailingLineEnding } from '../lines';
 import { concatChildren as serializeChildren } from '../serializer';
 import { registerInlineWidgetKind, mintWidgetShell } from '../inline/inline-widgets';
 import { matchDirectiveOpener, serializeDirective } from './grammar';
 export const DIRECTIVE_CONTAINER = 'directiveContainer';
 export const DIRECTIVE_LEAF = 'directiveLeaf';
 export const DIRECTIVE_TEXT = 'directiveText';
-/** The `:::` opener and closer bracket every directive body, whatever kind the name mints. */
+/** The `:::` opener and closer bracket every directive body, whatever kind the name maps to. */
 export const DIRECTIVE_BODY_WRAP = {
     afterOpenerLine: true,
     beforeCloserLine: true
@@ -24,10 +24,11 @@ export function registerDirectiveKinds() {
     if (isBlockKindRegistered(DIRECTIVE_CONTAINER))
         return; // idempotent for HMR / re-import
     registerBlockKind(declarePluginKind(DIRECTIVE_CONTAINER), {
+        label: 'Directive',
         mergeRole: 'container',
         editable: true,
         supportsInline: false,
-        // Opaque tier rule: no textual escape hatch at either edge, so both take the gap caret.
+        // An opaque container has no text of its own at either edge, so both take the gap caret.
         gapEdges: 'both',
         container: {
             contract: 'opaque',
@@ -51,11 +52,12 @@ export function registerDirectiveKinds() {
         })
     });
     registerBlockKind(declarePluginKind(DIRECTIVE_LEAF), {
+        label: 'Directive',
         gapEdges: 'none',
         mergeRole: 'not-mergeable',
         editable: true,
         supportsInline: false,
-        getContentRange: directiveLeafContentRange,
+        contentStart: { range: directiveLeafContentRange },
         keymap: DIRECTIVE_LEAF_KEYMAP,
         conformanceFixture: '::spoiler\n',
         closure: {
@@ -78,11 +80,8 @@ export function registerDirectiveKinds() {
     });
 }
 // ── Text tier: inline `:name[label]{attrs}` ────────────────────────────────────
-/**
- * The `:` recognizer (text-recognizer.ts) stamps this kind on the span it delimits. The widget
- * opts into `revealSource`, so focus swaps the island for editable source and blur/Enter commits
- * (the shared reveal primitive in widget-interaction.ts). Idempotent for HMR.
- */
+/** The `:` recognizer gives this kind to the span it delimits. The widget opts into `revealSource`,
+ *  so focus swaps it for its editable source. Idempotent for HMR. */
 export function registerDirectiveTextKind() {
     if (isInlineKindDeclared(DIRECTIVE_TEXT))
         return;
@@ -99,8 +98,8 @@ function buildDirectiveTextWidget(node, raw) {
     shell.textContent = raw.slice(node.start, node.end);
     return shell;
 }
-// Enter opens a paragraph sibling: a leaf never holds an in-line break, so the split reparses
-// its empty tail. Backspace/Delete take the not-mergeable walk, moving focus without joining.
+// Enter opens a paragraph sibling, since a leaf never holds a line break; Backspace and Delete at
+// an edge move focus without joining, as for any block that doesn't merge.
 const DIRECTIVE_LEAF_KEYMAP = [
     { chord: 'Enter', command: 'block.split' },
     { chord: 'Tab', command: 'block.insertTab' },
@@ -109,8 +108,8 @@ const DIRECTIVE_LEAF_KEYMAP = [
     { chord: 'Alt+ArrowUp', command: 'block.moveUp' },
     { chord: 'Alt+ArrowDown', command: 'block.moveDown' }
 ];
-// The `::name` fence is a dimmed marker prefix, on the heading marker-range mechanism. A raw
-// that no longer opens a fence reparses to a paragraph first, so the null branch is a floor.
+// The `::name` fence is a dimmed marker prefix, like a heading's. A raw that stops opening a fence
+// reparses to a paragraph first, so the null branch is only a fallback.
 function directiveLeafContentRange(node) {
     const fence = matchDirectiveOpener(trimTrailingLineEnding(node.raw));
     const start = fence ? fence.colonCount + fence.name.length : 0;
@@ -130,8 +129,7 @@ export function rebuildDirectiveContainerRaw(node) {
         closerColonCount: meta.closerColonCount,
         closerNewline: meta.closerNewline,
         lineEnding: meta.lineEnding,
-        // The parse side threads only the opener ending, so a mixed-ending directive recovers
-        // the closer's from the current raw, whose last line it is.
-        closerLineEnding: trailingLineEnding(node.raw)
+        // The closer is the raw's last line, so its ending is the raw's own, else the opener's.
+        closerLineEnding: ownTrailingLineEnding(node.raw) || undefined
     });
 }

package/dist/core/directive/registry.d.ts

@@ -1,11 +1,13 @@
 /**
- * Name-to-kind registry for the directive primitive: the shared opener resolves a fence's
- * `(tier, name)` here, then delegates to `fromDirective` or builds a lossless generic node.
+ * Name-to-kind registry for the directive syntax: the shared opener resolves a fence's
+ * `(tier, name)` (tier: container, leaf or text) here, then delegates to `fromDirective` or
+ * builds a lossless generic node.
  * Register-once with no unregister, the `customElements` model the schema registries follow.
  * Tier scopes the key, so a container and a leaf may share a name.
  */
 import type { DirectiveTier, DirectiveFence } from './grammar';
 import type { AnyBlockKind, PluginInlineKind, CstNode, InlineNode, Document } from '../nodes';
+import type { GrammarView } from '../../schema/block-openers';
 export interface ParsedDirective {
     fence: DirectiveFence;
     body?: Document;
@@ -15,7 +17,7 @@ export interface ParsedDirective {
     raw: string;
     closerColonCount: number;
     closerNewline: boolean;
-    /** Opener line ending; a factory stores it so a rebuild reproduces CRLF chrome lines. */
+    /** Opener line ending; a factory stores it so a rebuild keeps CRLF fence lines. */
     lineEnding: string;
 }
 export interface DirectiveDefinition {
@@ -24,16 +26,17 @@ export interface DirectiveDefinition {
     fromDirective?(parsed: ParsedDirective): CstNode | InlineNode;
 }
 export declare function registerDirective(tier: DirectiveTier, name: string, def: DirectiveDefinition): void;
-export declare function resolveDirective(tier: DirectiveTier, name: string): DirectiveDefinition | undefined;
+/** The name's definition under an editor's grammar; a name its plugin registered is absent where
+ *  the editor left that plugin out, so the fence reads as the generic directive. */
+export declare function resolveDirective(tier: DirectiveTier, name: string, grammar: GrammarView): DirectiveDefinition | undefined;
 /**
- * Pre-narrowed: the registration contract above guarantees a block node for these tiers, so the
- * union narrowing lives at this choke point instead of a cast per opener call site.
+ * Pre-narrowed: registration guarantees a block node for these tiers, so the union narrowing
+ * happens here once instead of a cast per opener call site.
  */
-export declare function resolveBlockDirectiveFactory(tier: 'leaf' | 'container', name: string): ((parsed: ParsedDirective) => CstNode) | undefined;
+export declare function resolveBlockDirectiveFactory(tier: 'leaf' | 'container', name: string, grammar: GrammarView): ((parsed: ParsedDirective) => CstNode) | undefined;
 export declare function isDirectiveRegistered(tier: DirectiveTier, name: string): boolean;
 /**
  * What "does this kind have a recognizer" must ask: a directive kind owns no opener of its own,
- * so an opener-registry probe alone reads the whole directive tier as unrecognizable.
+ * so checking the opener registry alone reads every directive kind as unrecognizable.
  */
 export declare function isDirectiveKind(kind: AnyBlockKind | PluginInlineKind): boolean;
-export declare function __resetDirectiveRegistryForTests(): void;

package/dist/core/directive/registry.js

@@ -1,11 +1,15 @@
 /**
- * Name-to-kind registry for the directive primitive: the shared opener resolves a fence's
- * `(tier, name)` here, then delegates to `fromDirective` or builds a lossless generic node.
+ * Name-to-kind registry for the directive syntax: the shared opener resolves a fence's
+ * `(tier, name)` (tier: container, leaf or text) here, then delegates to `fromDirective` or
+ * builds a lossless generic node.
  * Register-once with no unregister, the `customElements` model the schema registries follow.
  * Tier scopes the key, so a container and a leaf may share a name.
  */
-import { registerOnce } from '../../schema/register-once';
-const definitions = new Map();
+import { createPluginRegistry } from '../../schema/plugin-registry';
+const definitions = createPluginRegistry({
+    label: 'registerDirective',
+    isBuiltin: () => false
+});
 const keyOf = (tier, name) => `${tier}:${name}`;
 export function registerDirective(tier, name, def) {
     // Fail loud at registration so a tier/factory mismatch can't silently no-op at dispatch.
@@ -17,17 +21,19 @@ export function registerDirective(tier, name, def) {
         throw new Error(`registerDirective: text "${name}" is kind-only; fromDirective is not used for inline nodes.`);
     }
     const key = keyOf(tier, name);
-    registerOnce(definitions.has(key), () => definitions.set(key, def), `registerDirective: "${key}" is already registered. Directives are register-once.`);
+    definitions.register(key, def, `registerDirective: "${key}" is already registered. Directives are register-once.`);
 }
-export function resolveDirective(tier, name) {
-    return definitions.get(keyOf(tier, name));
+/** The name's definition under an editor's grammar; a name its plugin registered is absent where
+ *  the editor left that plugin out, so the fence reads as the generic directive. */
+export function resolveDirective(tier, name, grammar) {
+    return definitions.get(keyOf(tier, name), grammar.activation);
 }
 /**
- * Pre-narrowed: the registration contract above guarantees a block node for these tiers, so the
- * union narrowing lives at this choke point instead of a cast per opener call site.
+ * Pre-narrowed: registration guarantees a block node for these tiers, so the union narrowing
+ * happens here once instead of a cast per opener call site.
  */
-export function resolveBlockDirectiveFactory(tier, name) {
-    const factory = definitions.get(keyOf(tier, name))?.fromDirective;
+export function resolveBlockDirectiveFactory(tier, name, grammar) {
+    const factory = resolveDirective(tier, name, grammar)?.fromDirective;
     return factory;
 }
 export function isDirectiveRegistered(tier, name) {
@@ -35,15 +41,8 @@ export function isDirectiveRegistered(tier, name) {
 }
 /**
  * What "does this kind have a recognizer" must ask: a directive kind owns no opener of its own,
- * so an opener-registry probe alone reads the whole directive tier as unrecognizable.
+ * so checking the opener registry alone reads every directive kind as unrecognizable.
  */
 export function isDirectiveKind(kind) {
-    for (const def of definitions.values()) {
-        if (def.kind === kind)
-            return true;
-    }
-    return false;
-}
-export function __resetDirectiveRegistryForTests() {
-    definitions.clear();
+    return definitions.records().some(({ value }) => value.kind === kind);
 }

package/dist/core/directive/text-recognizer.d.ts

@@ -1,8 +1,9 @@
 /**
- * Inline text-directive recognizer for `:name[label]{attrs}`. It OWNS the whole span: returning
+ * Inline text-directive recognizer for `:name[label]{attrs}`. It owns the whole span: returning
  * `end` past the `[label]{attrs}` keeps the scanner's bracket stack from competing for the inner
  * `[label]`. Conservative by construction, declining unless `[` or `{` follows the name, so
  * `:smile:`, `10:30`, and `://` stay literal. Meaning is parsed elsewhere (`grammar.ts`).
  */
 import type { InlineNode, PluginInlineKind } from '../nodes';
-export declare function recognizeTextDirective(raw: string, pos: number, end: number, kind: PluginInlineKind): InlineNode | null;
+import type { GrammarView } from '../../schema/block-openers';
+export declare function recognizeTextDirective(raw: string, pos: number, end: number, kind: PluginInlineKind, grammar: GrammarView): InlineNode | null;

package/dist/core/directive/text-recognizer.js

@@ -1,5 +1,5 @@
 /**
- * Inline text-directive recognizer for `:name[label]{attrs}`. It OWNS the whole span: returning
+ * Inline text-directive recognizer for `:name[label]{attrs}`. It owns the whole span: returning
  * `end` past the `[label]{attrs}` keeps the scanner's bracket stack from competing for the inner
  * `[label]`. Conservative by construction, declining unless `[` or `{` follows the name, so
  * `:smile:`, `10:30`, and `://` stay literal. Meaning is parsed elsewhere (`grammar.ts`).
@@ -8,12 +8,8 @@ import { createBoundedMemo } from '../../bounded-memo';
 import { resolveDirective } from './registry';
 const isNameStart = (code) => (code >= 0x41 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a); // A-Z a-z
 const isNameChar = (code) => isNameStart(code) || (code >= 0x30 && code <= 0x39) || code === 0x2d; // + 0-9 -
-/**
- * Balanced-run matches for one block's raw. Without the memo, a paragraph carrying many `:name[`
- * starts pays a full block scan each. Matching is prefix-determined, so one stack pass answers
- * every consultation and the caller's `end` filters the result. Bounded rather than weak-keyed
- * because a string cannot key a WeakMap; two entries cover a block's own scan.
- */
+/** Balanced-run matches per block raw, so a paragraph with many `:name[` starts pays one scan:
+ *  matching is prefix-determined, and the caller's `end` filters the result. */
 const balancedRuns = createBoundedMemo({ cap: 2 });
 function matchBalancedRuns(raw) {
     const label = new Map();
@@ -50,7 +46,7 @@ function consumeBalanced(raw, open, end, openCh) {
     const close = (openCh === '[' ? runs.label : runs.attrs).get(open);
     return close !== undefined && close <= end ? close : -1;
 }
-export function recognizeTextDirective(raw, pos, end, kind) {
+export function recognizeTextDirective(raw, pos, end, kind, grammar) {
     // `://` is a scheme separator (http://, mailto:), never a directive.
     if (raw[pos + 1] === '/' && raw[pos + 2] === '/')
         return null;
@@ -82,6 +78,6 @@ export function recognizeTextDirective(raw, pos, end, kind) {
     }
     // Sibling-path parity with the block opener: a registered name resolves to the plugin's own
     // inline kind, an unregistered one keeps the generic `kind`.
-    const def = resolveDirective('text', raw.slice(pos + 1, nameEnd));
+    const def = resolveDirective('text', raw.slice(pos + 1, nameEnd), grammar);
     return { kind: (def?.kind ?? kind), start: pos, end: i };
 }

package/dist/core/escapable.d.ts

@@ -1,6 +1,2 @@
-/**
- * CommonMark's 32 escapable ASCII punctuation characters (§2.4). A core leaf because both the
- * inline scanner and the block-level link-reference parser (§4.7) need it, and neither should
- * import the other's directory to reach a lexical constant.
- */
+/** CommonMark's escapable ASCII punctuation (§2.4), shared by the inline and block parsers. */
 export declare const ESCAPABLE_PUNCTUATION: Set<string>;

package/dist/core/escapable.js

@@ -1,6 +1,2 @@
-/**
- * CommonMark's 32 escapable ASCII punctuation characters (§2.4). A core leaf because both the
- * inline scanner and the block-level link-reference parser (§4.7) need it, and neither should
- * import the other's directory to reach a lexical constant.
- */
+/** CommonMark's escapable ASCII punctuation (§2.4), shared by the inline and block parsers. */
 export const ESCAPABLE_PUNCTUATION = new Set('!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~');

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

@@ -1,12 +1,11 @@
 /**
  * Backtick-run indexing for code spans (CommonMark §6.1): a run of N backticks closes with the
  * next run of exactly N. Indexed once, then binary-searched per opener, because a per-opener
- * forward rescan to EOF turns a run-length ladder quadratic.
+ * forward rescan to EOF turns a sequence of growing run lengths quadratic.
  */
 /**
- * Wrap `content` as a code span. The fence runs one backtick past the longest run it encloses, so
- * nothing inside can close it; content touching a backtick at either edge takes a space pad too,
- * without which the fence and that byte merge into one longer run and the span closes elsewhere.
+ * The fence runs one backtick past the longest run inside, so nothing inside closes it; content
+ * with a backtick at an edge gets a space pad, or that backtick would merge into the fence.
  */
 export declare function wrapAsCodeSpan(content: string): string;
 /** Run start positions by run length, ascending within each length. */

package/dist/core/inline/backticks.js

@@ -1,12 +1,11 @@
 /**
  * Backtick-run indexing for code spans (CommonMark §6.1): a run of N backticks closes with the
  * next run of exactly N. Indexed once, then binary-searched per opener, because a per-opener
- * forward rescan to EOF turns a run-length ladder quadratic.
+ * forward rescan to EOF turns a sequence of growing run lengths quadratic.
  */
 /**
- * Wrap `content` as a code span. The fence runs one backtick past the longest run it encloses, so
- * nothing inside can close it; content touching a backtick at either edge takes a space pad too,
- * without which the fence and that byte merge into one longer run and the span closes elsewhere.
+ * The fence runs one backtick past the longest run inside, so nothing inside closes it; content
+ * with a backtick at an edge gets a space pad, or that backtick would merge into the fence.
  */
 export function wrapAsCodeSpan(content) {
     const fence = '`'.repeat(longestBacktickRun(content) + 1);