@voithos-labs/aragonite 0.10.3 → 0.10.7

package/dist/components/blocks/code/code-languages.js

@@ -1,41 +1,67 @@
 /**
- * Language registry for code-block tokenization. Nothing outside this directory
- * imports highlight.js directly; static vs. dynamic loading is a policy on top.
+ * The registry of languages code blocks are highlighted with. Nothing outside this directory
+ * imports highlight.js directly; whether a language loads eagerly is decided above this.
+ * Alternate spellings resolve to their canonical name here, so no caller keeps its own table.
+ * Every read takes an editor's activation, so a plugin's language shows only where it is listed.
  */
-const grammars = new Map();
-const aliases = new Map();
-/** Idempotent — repeat calls with the same name are no-ops. */
+import { createPluginRegistry } from '../../../schema/plugin-registry';
+import { fenceLanguage } from '../../../core/parsers/fence-syntax';
+const grammars = createPluginRegistry({
+    label: 'registerLanguage',
+    isBuiltin: () => false
+});
+/** Register-once: a name already taken throws (a dev server replaces). */
 export function registerLanguage(name, definition, aliasList = []) {
+    const { key, language, conflict } = languageEntry(name, definition, aliasList);
+    grammars.register(key, language, conflict);
+}
+/** The code bootstrap's entry: a language the test reset keeps, owned by no plugin. */
+export function registerBuiltinLanguage(name, definition, aliasList = []) {
+    const { key, language, conflict } = languageEntry(name, definition, aliasList);
+    grammars.registerCore(key, language, conflict);
+}
+function languageEntry(name, definition, aliasList) {
     const key = name.toLowerCase();
-    if (grammars.has(key))
-        return;
-    grammars.set(key, { name: key, definition });
-    for (const alias of aliasList) {
-        aliases.set(alias.toLowerCase(), key);
-    }
+    const aliases = [...new Set(aliasList.map((alias) => alias.toLowerCase()))];
+    return {
+        key,
+        language: { name: key, definition, aliases },
+        conflict: `registerLanguage: "${key}" is already registered. Languages are register-once.`
+    };
+}
+/** Whether the name is taken, whatever the activation: the check before a guarded register. */
+export function isLanguageRegistered(name) {
+    return grammars.has(name.toLowerCase());
+}
+/** Any spelling of a language to the one name it is registered under. A name of its own beats
+ *  another language's alternate spelling, so no grammar is hidden behind somebody's nickname. */
+function canonicalName(spelling, activation) {
+    const key = spelling.toLowerCase();
+    const languages = grammars.entries(activation);
+    if (languages.some(([name]) => name === key))
+        return key;
+    let canonical = key;
+    for (const [name, language] of languages)
+        if (language.aliases.includes(key))
+            canonical = name;
+    return canonical;
 }
 /** Info strings with trailing attributes (`js {1-3}`) resolve on the first token. */
-export function getLanguageGrammar(infoString) {
-    const trimmed = infoString.trim();
-    if (trimmed.length === 0)
+export function getLanguageGrammar(infoString, activation) {
+    const language = fenceLanguage(infoString);
+    if (language === '')
         return null;
-    const firstToken = trimmed.split(/\s+/)[0].toLowerCase();
-    const resolvedName = aliases.get(firstToken) ?? firstToken;
-    return grammars.get(resolvedName) ?? null;
+    return grammars.get(canonicalName(language, activation), activation) ?? null;
 }
-/**
- * Every registered grammar name, plus every alias, sorted — what the language picker
- * offers. Aliases are listed as their own entries: a user typing `js` should find it
- * rather than having to know it resolves to `javascript`.
- */
-export function listLanguages() {
-    const names = new Set(grammars.keys());
-    for (const alias of aliases.keys())
-        names.add(alias);
-    return [...names].sort();
-}
-/** Test-only: clear all registered languages. */
-export function __resetRegistryForTests() {
-    grammars.clear();
-    aliases.clear();
+/** Every registered language once, under its canonical name, sorted: the picker's rows. */
+export function listLanguages(activation) {
+    return grammars
+        .entries(activation)
+        .map(([name]) => name)
+        .sort();
+}
+/** The alternate spellings a language answers to, from any spelling of it, so a picker's
+ *  filter matches `rs` to `rust` without a table of its own. */
+export function getLanguageAliases(name, activation) {
+    return grammars.get(canonicalName(name, activation), activation)?.aliases ?? [];
 }

package/dist/components/blocks/code/code-paste-surface.d.ts

@@ -1,6 +1,7 @@
 /**
- * PasteSurface for fenced code blocks. Paste is always literal text, so the structural
- * hook is omitted and pasteDispatch falls through to the inline path.
+ * PasteSurface for fenced code blocks. Paste is always literal text, so the structural hook is
+ * omitted and pasteDispatch falls through to the inline path; the write that stores the splice
+ * runs the fence rule, which grows the fence past a run the paste lands.
  */
 import type { PasteSurface } from '../../../tree-operations/paste-surfaces';
 export declare const codePasteSurface: PasteSurface;

package/dist/components/blocks/code/code-paste-surface.js

@@ -1,29 +1,20 @@
 /**
- * PasteSurface for fenced code blocks. Paste is always literal text, so the structural
- * hook is omitted and pasteDispatch falls through to the inline path.
+ * PasteSurface for fenced code blocks. Paste is always literal text, so the structural hook is
+ * omitted and pasteDispatch falls through to the inline path; the write that stores the splice
+ * runs the fence rule, which grows the fence past a run the paste lands.
  */
-import { metadataOf } from '../../../core/nodes';
 import { trailingLineEnding, trimTrailingLineEnding } from '../../../core/lines';
-import { computeCodePaste } from './code-paste';
 export const codePasteSurface = {
     kind: 'fencedCode',
-    onInlinePaste(node, offset, text, preDelete) {
-        const meta = metadataOf(node, 'fencedCode');
-        const lineEnding = trailingLineEnding(node.raw);
+    onInlinePaste(node, offset, text, preDelete, _store, documentEnding) {
         const display = trimTrailingLineEnding(node.raw);
         const start = preDelete?.start ?? offset;
-        const end = preDelete?.end ?? offset;
-        const result = computeCodePaste({
-            display,
-            selection: { start, end },
-            pasted: text,
-            fenceMarker: meta.fenceMarker,
-            fenceLength: meta.fenceLength,
-            closed: meta.closed
-        });
         return {
-            newRaw: result.text + lineEnding,
-            caretOffset: result.cursor
+            newRaw: display.slice(0, start) +
+                text +
+                display.slice(preDelete?.end ?? offset) +
+                trailingLineEnding(node.raw, documentEnding),
+            caretOffset: start + text.length
         };
     }
 };

package/dist/components/blocks/code/code-renderer.d.ts

@@ -1,18 +1,34 @@
 /**
- * Code-block renderer. Produces a DocumentFragment with dimmed marker spans
- * for fences and tokenized spans for the body. Invariant (G1.28):
- *   fragment.textContent === trimTrailingLineEnding(node.raw)
+ * Draws a fenced source, a code block's or any plugin kind's that holds its own fence: the fence
+ * lines as dimmed markers the marker-hiding modes collapse, the body as its caller paints it. The
+ * fragment's text is exactly the source's (G1.28).
  */
 import type { NodeView } from '../../../core/node-views';
+import { type FenceRun } from '../../../core/parsers/fence-syntax';
+import type { PluginActivation } from '../../../schema/plugin-activation';
 export interface FencedCodeSlice {
     openerLine: string;
     body: string;
     closerLine: string;
     infoString: string;
 }
+/** A fenced source split at its fence lines: each line keeps its own ending. */
+export interface FencedSource {
+    opener: string;
+    body: string;
+    closer: string;
+}
+/** `text` split where {@link fenceAnatomy} reads its fence lines; null when it opens no fence. */
+export declare function sliceFencedSource(text: string, fence?: FenceRun): FencedSource | null;
 export declare function sliceFencedCode(node: NodeView): FencedCodeSlice;
 export declare function mapHljsClass(hljsClass: string): string;
 export declare function walkHljsNodes(source: Node, target: DocumentFragment | HTMLElement): void;
 /** `ignoreIllegals` is set so mid-typing invalid syntax doesn't throw. */
-export declare function tokenizeBody(body: string, infoString: string): DocumentFragment;
-export declare function renderCodeBlock(node: NodeView): DocumentFragment;
+export declare function tokenizeBody(body: string, infoString: string, activation: PluginActivation): DocumentFragment;
+/** The line break before the closer belongs to the closer's fence line, so modes that hide it
+ *  take that break too; a blank body keeps it, as the only line the caret can sit on. */
+export declare function fenceBodyAsDrawn(source: FencedSource): string;
+/** A fenced source as DOM: the fence lines as markers, the body through `paintBody`. */
+export declare function renderFencedSource(source: FencedSource, paintBody: (body: string) => Node): DocumentFragment;
+/** `activation` is the editor's, so a language whose plugin it left out renders untokenized. */
+export declare function renderCodeBlock(node: NodeView, activation: PluginActivation): DocumentFragment;

package/dist/components/blocks/code/code-renderer.js

@@ -1,39 +1,39 @@
 /**
- * Code-block renderer. Produces a DocumentFragment with dimmed marker spans
- * for fences and tokenized spans for the body. Invariant (G1.28):
- *   fragment.textContent === trimTrailingLineEnding(node.raw)
+ * Draws a fenced source, a code block's or any plugin kind's that holds its own fence: the fence
+ * lines as dimmed markers the marker-hiding modes collapse, the body as its caller paints it. The
+ * fragment's text is exactly the source's (G1.28).
  */
 import { metadataOf } from '../../../core/nodes';
-import { trimTrailingLineEnding } from '../../../core/lines';
+import { displayLines, ownTrailingLineEnding, trimTrailingLineEnding } from '../../../core/lines';
+import { fenceAnatomy } from '../../../core/parsers/fence-syntax';
+import { createCaretAnchor } from '../../../cursor/widget-offset';
 import { devWarn } from '../../../dev-warn';
 import { assertInvariant } from '../../../assert';
 import { checkRenderedTextFidelity } from '../../../invariants/render-fidelity';
 import hljs from 'highlight.js/lib/core';
 import { getLanguageGrammar } from './code-languages';
-export function sliceFencedCode(node) {
-    const meta = metadataOf(node, 'fencedCode');
-    const raw = node.raw;
-    const firstNewline = raw.indexOf('\n');
-    if (firstNewline === -1) {
-        return { openerLine: raw, body: '', closerLine: '', infoString: meta.info ?? '' };
-    }
-    const openerLine = raw.slice(0, firstNewline + 1);
-    if (!meta.closed) {
-        return {
-            openerLine,
-            body: raw.slice(openerLine.length),
-            closerLine: '',
-            infoString: meta.info ?? ''
-        };
-    }
-    const closerStart = findClosingFenceStart(raw, openerLine.length, meta.fenceMarker, meta.fenceLength);
+/** `text` split where {@link fenceAnatomy} reads its fence lines; null when it opens no fence. */
+export function sliceFencedSource(text, fence) {
+    const anatomy = fenceAnatomy(text, fence);
+    if (!anatomy)
+        return null;
     return {
-        openerLine,
-        body: raw.slice(openerLine.length, closerStart),
-        closerLine: raw.slice(closerStart),
-        infoString: meta.info ?? ''
+        opener: text.slice(0, anatomy.bodyStart),
+        body: text.slice(anatomy.bodyStart, anatomy.closerStart),
+        closer: text.slice(anatomy.closerStart)
     };
 }
+export function sliceFencedCode(node) {
+    const infoString = metadataOf(node, 'fencedCode').info ?? '';
+    const source = sliceFencedSource(node.raw, codeFenceRun(node));
+    if (!source) {
+        // Not a parse result: a line the grammar reads as no fence is all structure.
+        const bodyStart = node.raw.indexOf('\n') + 1 || node.raw.length;
+        const openerLine = node.raw.slice(0, bodyStart);
+        return { openerLine, body: node.raw.slice(bodyStart), closerLine: '', infoString };
+    }
+    return { openerLine: source.opener, body: source.body, closerLine: source.closer, infoString };
+}
 // ── hljs class → code-tok class mapping ───────────────────────────────────
 const HLJS_CLASS_MAP = {
     'hljs-keyword': 'code-tok-keyword',
@@ -92,20 +92,22 @@ export function walkHljsNodes(source, target) {
     }
 }
 // ── Body tokenization ─────────────────────────────────────────────────────
-const registeredWithHljs = new Set();
+// The definition highlight.js last took under each name, checked against the language registry
+// on every read, so a grammar the registry replaced (a reset, a dev-server re-run) replaces here.
+const handedToHljs = new Map();
 /** `ignoreIllegals` is set so mid-typing invalid syntax doesn't throw. */
-export function tokenizeBody(body, infoString) {
+export function tokenizeBody(body, infoString, activation) {
     const frag = document.createDocumentFragment();
     if (body.length === 0)
         return frag;
-    const grammar = getLanguageGrammar(infoString);
+    const grammar = getLanguageGrammar(infoString, activation);
     if (!grammar) {
         frag.appendChild(document.createTextNode(body));
         return frag;
     }
-    if (!registeredWithHljs.has(grammar.name)) {
+    if (handedToHljs.get(grammar.name) !== grammar.definition) {
         hljs.registerLanguage(grammar.name, grammar.definition);
-        registeredWithHljs.add(grammar.name);
+        handedToHljs.set(grammar.name, grammar.definition);
     }
     // `template.innerHTML` normalizes every `\r\n`/`\r` to `\n`, so a CRLF body is
     // highlighted as pure LF and its endings restored positionally afterward.
@@ -122,9 +124,8 @@ export function tokenizeBody(body, infoString) {
         restoreLineEndings(frag, body);
     return frag;
 }
-// An in-order text-node walk rewrites the k-th `\n` back to the k-th original ending.
-// Counts match by construction: every `\r` was stripped before highlighting, so neither
-// hljs nor the HTML parser adds or drops a newline.
+// An in-order text-node walk rewrites the k-th `\n` back to the k-th original ending; every
+// `\r` was stripped before highlighting, so the counts match.
 function restoreLineEndings(root, originalBody) {
     const endings = originalBody.match(/\r\n|\r|\n/g);
     if (!endings)
@@ -144,22 +145,47 @@ function restoreLineEndings(root, originalBody) {
         }
     };
     restore(root);
-    // A count mismatch would silently write `undefined` into committed bytes downstream,
-    // so make an hljs-faithfulness regression loud at this seam instead.
+    // A count mismatch would silently write `undefined` into the committed bytes, so a
+    // change in what hljs produces fails loudly here instead.
     if (next !== endings.length) {
         devWarn('code-renderer', `restoreLineEndings count mismatch: ${next} fragment newlines vs ${endings.length} source endings`);
     }
 }
-// ── Fence marker rendering ────────────────────────────────────────────────
+// ── Fenced source rendering ───────────────────────────────────────────────
+/** The line break before the closer belongs to the closer's fence line, so modes that hide it
+ *  take that break too; a blank body keeps it, as the only line the caret can sit on. */
+export function fenceBodyAsDrawn(source) {
+    const ending = ownTrailingLineEnding(source.body);
+    const rehomed = source.closer !== '' && ending !== '' && /\S/.test(source.body);
+    return rehomed ? source.body.slice(0, -ending.length) : source.body;
+}
+/** A fenced source as DOM: the fence lines as markers, the body through `paintBody`. */
+export function renderFencedSource(source, paintBody) {
+    const frag = document.createDocumentFragment();
+    const body = fenceBodyAsDrawn(source);
+    const separator = source.body.slice(body.length);
+    if (source.opener !== '')
+        frag.appendChild(makeFenceLine(openerParts(source.opener)));
+    frag.appendChild(paintBody(body));
+    // Chromium paints no caret on an empty last body line with only the hidden closer after it, so
+    // an anchor holds that line; the modes that paint the closer hide it in CSS.
+    if (separator !== '' && body.endsWith('\n'))
+        frag.appendChild(createCaretAnchor('closer'));
+    if (source.closer !== '') {
+        const parts = separator !== '' ? [document.createTextNode(separator)] : [];
+        parts.push(makeMarkerSpan(source.closer, 'md-fence'));
+        frag.appendChild(makeFenceLine(parts));
+    }
+    return frag;
+}
 function makeMarkerSpan(text, extraClass) {
     const span = document.createElement('span');
-    span.className = extraClass ? `md-marker ${extraClass}` : 'md-marker';
+    span.className = `md-marker ${extraClass}`;
     span.textContent = text;
     return span;
 }
-// A fence line's newline is a bare text node CSS cannot reach; wrapping the whole line
-// lets reading/preview modes collapse it with `display: none`. Layout-neutral in source
-// mode — an inline span under `white-space: pre` still breaks on its inner `\n`.
+// A fence line's newline is a bare text node CSS cannot reach, so wrapping the whole line lets
+// the marker-hiding modes collapse it with `display: none`.
 function makeFenceLine(parts) {
     const line = document.createElement('span');
     line.className = 'md-fence-line';
@@ -167,94 +193,33 @@ function makeFenceLine(parts) {
         line.appendChild(part);
     return line;
 }
-function renderOpenerLine(slice, fenceMarker, fenceLength) {
-    const frag = document.createDocumentFragment();
-    if (slice.openerLine.length === 0)
-        return frag;
-    const fenceChars = fenceMarker.repeat(fenceLength);
-    const openerWithoutNewline = slice.openerLine.replace(/\n$/, '');
-    const hasTrailingNewline = slice.openerLine.endsWith('\n');
-    // The fence may sit behind 0–3 spaces of indent; carry it inside the fence-marker
-    // span so textContent keeps every opener byte.
-    const indent = openerWithoutNewline.match(/^ {0,3}/)[0];
-    const parts = [makeMarkerSpan(indent + fenceChars, 'md-fence')];
-    const afterFence = openerWithoutNewline.slice(indent.length + fenceChars.length);
-    if (afterFence.length > 0) {
-        parts.push(makeMarkerSpan(afterFence, 'md-lang'));
-    }
-    if (hasTrailingNewline) {
-        parts.push(document.createTextNode('\n'));
-    }
-    frag.appendChild(makeFenceLine(parts));
-    return frag;
-}
-function renderCloserLine(slice, leadingNewline) {
-    const frag = document.createDocumentFragment();
-    if (slice.closerLine.length === 0)
-        return frag;
-    const parts = [];
-    // The line break before the closer belongs to the closer's fence line, not the
-    // body's last code line; owning it here lets the wrapper hide both together.
-    if (leadingNewline)
-        parts.push(document.createTextNode('\n'));
-    parts.push(makeMarkerSpan(slice.closerLine, 'md-fence'));
-    frag.appendChild(makeFenceLine(parts));
-    return frag;
+/** The opener's indent and marker run, then its info string, then its line ending. */
+function openerParts(opener) {
+    const [{ text, ending }] = displayLines(opener);
+    const runEnd = fenceAnatomy(text)?.runEnd ?? text.length;
+    const parts = [makeMarkerSpan(text.slice(0, runEnd), 'md-fence')];
+    if (runEnd < text.length)
+        parts.push(makeMarkerSpan(text.slice(runEnd), 'md-lang'));
+    if (ending !== '')
+        parts.push(document.createTextNode(ending));
+    return parts;
 }
 // ── Top-level render ─────────────────────────────────────────────────────
-export function renderCodeBlock(node) {
-    const slice = trimSliceTail(sliceFencedCode(node));
-    const meta = metadataOf(node, 'fencedCode');
-    const frag = document.createDocumentFragment();
-    // The newline before the closer is re-homed onto the closer's fence line, so
-    // reading/preview collapse the bottom blank line with it. An all-blank body is the
-    // exception: stealing its terminating `\n` would drop a visible line.
-    const hasCloser = slice.closerLine.length > 0;
-    // `/\S/` deliberately conflates a whitespace-only body (spaces/tabs, no content
-    // line) with a truly-blank one: both keep their separator and render like blanks.
-    const bodyHasContentLine = /\S/.test(slice.body);
-    const separatorNewline = hasCloser && slice.body.endsWith('\n') && bodyHasContentLine;
-    const bodyText = separatorNewline ? slice.body.slice(0, -1) : slice.body;
-    frag.appendChild(renderOpenerLine(slice, meta.fenceMarker, meta.fenceLength));
-    frag.appendChild(tokenizeBody(bodyText, slice.infoString));
-    // An empty last body line ends the body in `\n` with only the (hidden) closer after it.
-    // Chromium paints no caret after a trailing `\n` unless something follows, so it
-    // canonicalises the seat to BEFORE the newline and the next key lands one byte early —
-    // the second line of a code block was untypeable in live mode. A `br` anchors the line
-    // without touching textContent; source mode, where the closer line itself follows, hides
-    // it in CSS.
-    if (separatorNewline && bodyText.endsWith('\n')) {
-        const anchor = document.createElement('br');
-        anchor.dataset.caretAnchor = 'closer';
-        frag.appendChild(anchor);
-    }
-    frag.appendChild(renderCloserLine(slice, separatorNewline));
-    assertInvariant('rendered-text-fidelity', () => checkRenderedTextFidelity(frag.textContent ?? '', trimTrailingLineEnding(node.raw)));
+/** `activation` is the editor's, so a language whose plugin it left out renders untokenized. */
+export function renderCodeBlock(node, activation) {
+    const display = trimTrailingLineEnding(node.raw);
+    const info = metadataOf(node, 'fencedCode').info ?? '';
+    const source = sliceFencedSource(display, codeFenceRun(node)) ?? {
+        opener: display,
+        body: '',
+        closer: ''
+    };
+    const frag = renderFencedSource(source, (body) => tokenizeBody(body, info, activation));
+    assertInvariant('rendered-text-fidelity', () => checkRenderedTextFidelity(frag.textContent ?? '', display));
     return frag;
 }
 // ── Internal ─────────────────────────────────────────────────────────────────
-// The block's trailing line ending never enters the fragments: strip it from whichever
-// slice piece carries the tail, so G1.28 holds by construction — CRLF included.
-function trimSliceTail(slice) {
-    if (slice.closerLine.length > 0)
-        return { ...slice, closerLine: trimTrailingLineEnding(slice.closerLine) };
-    if (slice.body.length > 0)
-        return { ...slice, body: trimTrailingLineEnding(slice.body) };
-    return { ...slice, openerLine: trimTrailingLineEnding(slice.openerLine) };
-}
-function findClosingFenceStart(raw, searchStart, fenceMarker, fenceLength) {
-    const fencePattern = new RegExp(`^ {0,3}${fenceMarker}{${fenceLength},}\\s*$`);
-    let lineEnd = raw.length;
-    while (lineEnd > searchStart) {
-        const lineStart = raw.lastIndexOf('\n', lineEnd - 2) + 1;
-        if (lineStart < searchStart)
-            break;
-        const line = raw.slice(lineStart, lineEnd).replace(/\n$/, '');
-        if (fencePattern.test(line)) {
-            return lineStart;
-        }
-        lineEnd = lineStart;
-    }
-    // Unreachable when the parser's `closed` flag is consistent with raw.
-    return raw.length;
+function codeFenceRun(node) {
+    const meta = metadataOf(node, 'fencedCode');
+    return { marker: meta.fenceMarker, length: meta.fenceLength };
 }

package/dist/components/blocks/directive/DirectiveContainerBlock.svelte

@@ -1,10 +1,11 @@
 <script lang="ts">
-	// The generic render surface for an unregistered `:::name` directive, built on the
-	// same `createContainerBlock` seam a plugin reaches through the barrel. Chrome stays a
-	// dimmed marker over a gutter rail, not a card box — a document should feel like a document.
+	// How an unregistered `:::name` directive renders, built on the same `createContainerBlock`
+	// helper a plugin gets from the public barrel. Its marker is a dimmed line over a left
+	// border, not a card box: a document should look like a document.
 	import { createContainerBlock } from '../../../editor-actions/plugin/container';
 	import BlockList from '../../BlockList.svelte';
 	import type { NodeView } from '../../../core/node-views';
+	import { firstDisplayLine } from '../../../core/lines';
 
 	let { node, index, myPath = [] }: { node: NodeView; index: number; myPath?: number[] } = $props();
 
@@ -12,11 +13,7 @@
 
 	// The opener line sliced verbatim, not rebuilt from metadata: the line can also
 	// carry an indent, attributes, or trailing spaces the metadata does not hold.
-	const marker = $derived.by(() => {
-		const end = node.raw.indexOf('\n');
-		const line = end === -1 ? node.raw : node.raw.slice(0, end);
-		return line.endsWith('\r') ? line.slice(0, -1) : line;
-	});
+	const marker = $derived(firstDisplayLine(node.raw).text);
 
 	const { blockListProps, containerApi, handleKeydown } = createContainerBlock({
 		getNode: () => node,

package/dist/components/blocks/directive/activate-directives.d.ts

@@ -1,7 +1,7 @@
 /**
- * The public activation entry for the `:::name` directive primitive, on the `@voithos-labs/aragonite/plugin`
- * barrel: grammar plus the generic container and leaf render. A pure-GFM consumer that never calls
- * it leaves `:::` unclaimed. Lives in `components/` because it binds Svelte components, which core
- * must not reach. Every registration guards its public probe, so repeat calls are safe.
+ * Turns on the `:::name` directive syntax: the grammar plus the generic container and leaf
+ * components. Exported from `@voithos-labs/aragonite/plugin`; a consumer that never calls it
+ * leaves `:::` as ordinary text. Lives in `components/` because it binds Svelte components,
+ * which core may not import. Each registration checks first, so calling this twice is safe.
  */
 export declare function activateDirectives(): void;

package/dist/components/blocks/directive/activate-directives.js

@@ -1,23 +1,28 @@
 /**
- * The public activation entry for the `:::name` directive primitive, on the `@voithos-labs/aragonite/plugin`
- * barrel: grammar plus the generic container and leaf render. A pure-GFM consumer that never calls
- * it leaves `:::` unclaimed. Lives in `components/` because it binds Svelte components, which core
- * must not reach. Every registration guards its public probe, so repeat calls are safe.
+ * Turns on the `:::name` directive syntax: the grammar plus the generic container and leaf
+ * components. Exported from `@voithos-labs/aragonite/plugin`; a consumer that never calls it
+ * leaves `:::` as ordinary text. Lives in `components/` because it binds Svelte components,
+ * which core may not import. Each registration checks first, so calling this twice is safe.
  */
 import { activateDirectiveGrammar } from '../../../core/directive/activate';
 import { registerBlockComponent, defineBlockComponent, isBlockComponentRegistered } from '../../../schema/block-component-registry';
 import { declaredPluginKind } from '../../../schema/plugin-kind';
+import { registerAsCore } from '../../../schema/plugin-install';
 import { DIRECTIVE_CONTAINER, DIRECTIVE_LEAF } from '../../../core/directive/kinds';
 import DirectiveContainerBlock from './DirectiveContainerBlock.svelte';
 import TextEditableBlock from '../text/TextEditableBlock.svelte';
 export function activateDirectives() {
-    activateDirectiveGrammar();
-    if (!isBlockComponentRegistered(DIRECTIVE_CONTAINER)) {
-        registerBlockComponent(declaredPluginKind(DIRECTIVE_CONTAINER), defineBlockComponent(DirectiveContainerBlock));
-    }
-    // The leaf's descriptor already drives its dimmed marker and split behavior, so it
-    // reuses the built-in text surface directly.
-    if (!isBlockComponentRegistered(DIRECTIVE_LEAF)) {
-        registerBlockComponent(declaredPluginKind(DIRECTIVE_LEAF), defineBlockComponent(TextEditableBlock, () => ({ blockClass: 'directive-leaf' })));
-    }
+    // The shared directive kinds and their components belong to no plugin, whichever plugin's setup
+    // turns directives on, so an editor that left that plugin out still reads `:::name` as generic.
+    registerAsCore(() => {
+        activateDirectiveGrammar();
+        if (!isBlockComponentRegistered(DIRECTIVE_CONTAINER)) {
+            registerBlockComponent(declaredPluginKind(DIRECTIVE_CONTAINER), defineBlockComponent(DirectiveContainerBlock));
+        }
+        // The leaf's kind descriptor already drives its dimmed marker and split behavior, so it
+        // reuses the built-in text block component as is.
+        if (!isBlockComponentRegistered(DIRECTIVE_LEAF)) {
+            registerBlockComponent(declaredPluginKind(DIRECTIVE_LEAF), defineBlockComponent(TextEditableBlock, () => ({ blockClass: 'directive-leaf' })));
+        }
+    });
 }