@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/plugins/admonitions/github-alert-kind.js

@@ -1,31 +1,30 @@
 /**
- * Native GitHub alerts as a strip container in the blockquote mold, bytes kept and
- * never rewritten to `:::note`. The marker lives only in the container's raw +
- * metadata, so `strip(raw)` equals the serialized children. A separate kind rather
- * than a directive-admonition variant, so kind stability and rebuildRaw stay
- * unambiguous per kind (the ATX/setext heading precedent).
+ * Native GitHub alerts as a strip container shaped like a blockquote: the source bytes are
+ * kept, never rewritten to `:::note`. The marker lives only in the container's raw and
+ * metadata, so `strip(raw)` equals the serialized children. Its own kind rather than a
+ * variant of the directive admonition, so kind stability and rebuildRaw stay unambiguous.
  */
-import { OPENER_PRIORITIES, blockquoteExtent, containerClosure, declarePluginKind, declaredPluginKind, defineBlockComponent, getPluginMetadata, parseContainerBody, registerBlockComponent, registerBlockKind, registerBlockOpener, serializeChildren, setPluginMetadata } from '../../plugin';
+import { OPENER_PRIORITIES, blockquoteExtent, containerClosure, declarePluginKind, declaredPluginKind, defineBlockComponent, displayLines, firstLineEnding, getPluginMetadata, joinDisplayLines, ownTrailingLineEnding, parseContainerBody, registerBlockComponent, registerBlockKind, registerBlockOpener, serializeChildren, setPluginMetadata } from '../../plugin';
 import { matchAlertMarker, stripQuoteMarker } from './gh-alert';
 import { GITHUB_ALERT } from './kinds';
 import AdmonitionBlock from './AdmonitionBlock.svelte';
-/** The `> [!TYPE]` marker line is the alert's own chrome, so a blank against it separates
- *  rather than materializing; nothing closes the alert below. */
+/** The `> [!TYPE]` line is the alert's own marker, so a blank line against it separates
+ *  rather than becoming a block of its own; nothing closes the alert below. */
 const BODY_WRAP = { afterOpenerLine: true };
 function tryOpen(ctx) {
     const alertType = matchAlertMarker(ctx.line.text);
     if (!alertType)
         return null;
-    // The built-in extent scan, not the marker regex, is the authority on whether this line
-    // opens a blockquote: declining on a zero-line claim keeps a marker-rule drift from
-    // reaching the parse loop as a non-advancing return.
-    const { raw, nextIndex } = blockquoteExtent(ctx.lines, ctx.index, ctx.end);
+    // The built-in extent scan, not the marker regex, decides whether this line opens a
+    // blockquote; backing out on zero lines keeps a no-progress return out of the parse loop.
+    const { raw, nextIndex } = blockquoteExtent(ctx.lines, ctx.index, ctx.end, ctx.grammar);
     const consumed = nextIndex - ctx.index;
     if (consumed <= 0)
         return null;
     // A fresh parse entry, so the body's own line 0 must not read as the document top.
     const body = parseContainerBody(stripBody(ctx.lines, ctx.index + 1, nextIndex), BODY_WRAP, {
-        scope: 'fragment'
+        scope: 'fragment',
+        grammar: ctx.grammar
     });
     const node = {
         kind: declaredPluginKind(GITHUB_ALERT),
@@ -44,48 +43,40 @@ function stripBody(lines, start, end) {
         out += stripQuoteMarker(lines[i].text) + lines[i].lineEnding;
     return out;
 }
-/** Splitting the body on `\n` keeps a `\r` at each segment's tail, so CRLF rides through;
- *  the marker's own ending is read off the current raw. */
+/** Every body line keeps its own ending; the marker line keeps the one the current raw gives it. */
 export function rebuildGithubAlertRaw(node) {
     const alertType = getPluginMetadata(node)?.alertType ?? 'NOTE';
     const marker = `> [!${alertType}]`;
     const body = (node.innerPrefix ?? '') + serializeChildren(node.children ?? []) + (node.innerSuffix ?? '');
     if (body === '') {
-        node.raw = node.raw.endsWith('\n') ? marker + firstLineEnding(node.raw) : marker;
+        node.raw = marker + ownTrailingLineEnding(node.raw);
         return;
     }
-    node.raw = marker + firstLineEnding(node.raw) + prefixQuoteLines(body);
-}
-/** Not `core/lines.ts`'s `trailingLineEnding`: on a mixed-ending block that reader would
- *  rewrite the marker's CRLF to LF. Rebuilding threads each line's own ending. */
-function firstLineEnding(raw) {
-    const nl = raw.indexOf('\n');
-    if (nl < 0)
-        return '\n';
-    return raw[nl - 1] === '\r' ? '\r\n' : '\n';
+    const markerEnding = firstLineEnding(node.raw) ?? firstLineEnding(body) ?? '\n';
+    node.raw = marker + markerEnding + prefixQuoteLines(body);
 }
 function prefixQuoteLines(body) {
-    const lines = body.split('\n');
-    return lines
-        .map((line, i) => {
-        if (i === lines.length - 1 && line === '')
-            return '';
-        if (line === '' || line === '\r')
-            return `>${line}`;
-        return `> ${line}`;
-    })
-        .join('\n');
+    const lines = displayLines(body);
+    return joinDisplayLines(lines.map((line, i) => {
+        // The empty line after a final break is no line of its own.
+        if (i === lines.length - 1 && line.text === '')
+            return line;
+        return { ...line, text: line.text === '' ? '>' : `> ${line.text}` };
+    }));
 }
 export function registerGithubAlert() {
     const kind = declarePluginKind(GITHUB_ALERT);
     registerBlockOpener(kind, {
-        // Below blockquote so the alert form is claimed first; its own slot, distinct
-        // from every other opener, so the co-installed bundle stays unique (G1.10).
+        // Below blockquote so the alert form matches first, at a priority no other opener
+        // uses, so a bundle installing them all keeps every priority unique (G1.10).
         priority: OPENER_PRIORITIES.blockquote - 5,
         tryOpen,
         interruptsParagraph: (t) => matchAlertMarker(t) !== null
     });
     registerBlockKind(kind, {
+        label: 'Alert',
+        // A note reads as part of the text around it, so it shows no drag handle.
+        pageRole: 'prose',
         gapEdges: 'none',
         mergeRole: 'container',
         editable: true,

package/dist/plugins/admonitions/index.js

@@ -1,8 +1,8 @@
 // Two kinds sharing one component: the `:::name` directives, which all resolve to
 // one admonition kind, and native GitHub alerts (`> [!NOTE]`, kind `githubAlert`).
 export { admonitionsPlugin } from './register';
-// convertGithubAlerts is naive full-text and rewrites inside code fences; for a whole
-// document prefer convertGithubAlertsInDocument, which scopes through the parser.
+// convertGithubAlerts scans plain text and rewrites inside code fences too; for a whole
+// document prefer convertGithubAlertsInDocument, which goes through the parser.
 export { convertGithubAlerts, hasGithubAlert } from './gh-alert';
 export { convertGithubAlertsInDocument } from './convert-document';
 export { ADMONITION_KINDS, GITHUB_ALERT } from './kinds';

package/dist/plugins/admonitions/kinds.d.ts

@@ -20,7 +20,7 @@ export interface AdmonitionMetadata {
     lineEnding: string;
 }
 /** The marker's type as typed (`NOTE`, `Note`), stored verbatim so `rebuildRaw` re-emits
- *  the source casing; readers lowercase through `coerceAdmonitionName` for display. */
+ *  the source casing; display code lowercases it through `coerceAdmonitionName`. */
 export interface GithubAlertMetadata {
     alertType: string;
 }

package/dist/plugins/admonitions/register.js

@@ -2,11 +2,20 @@
  * Two block kinds from one setup, so this wires `definePlugin` directly rather than
  * the single-kind `definePluginBlock` sugar.
  */
-import { definePlugin } from '../../plugin';
+import { definePlugin, registerInsertEntry } from '../../plugin';
 import { registerAdmonitions } from './admonition-kind';
 export function admonitionsPlugin(options) {
     return definePlugin({
         name: 'admonitions',
-        setup: () => registerAdmonitions(options)
+        setup() {
+            registerAdmonitions(options);
+            registerInsertEntry({
+                id: 'note',
+                label: 'Note',
+                icon: 'info',
+                keywords: ['note', 'admonition', 'callout'],
+                markdown: ':::note\n\n:::\n'
+            });
+        }
     });
 }

package/dist/plugins/details/DetailsBlock.svelte

@@ -1,7 +1,6 @@
 <script lang="ts">
-	// Collapse-ness has one definition, the descriptor's `reservedChrome.isCollapsed` probe.
-	// The reader's transient disclosure layers over it by feeding the factory the effective
-	// state, so the window clamp, focus clamp and caret never disagree.
+	// The document's collapsed state comes from `reservedChrome.isCollapsed`; reading mode's
+	// temporary open state is passed to the factory on top of it, so windowing and focus agree.
 	import {
 		BlockList,
 		createContainerBlock,
@@ -22,15 +21,15 @@
 			getIndex: () => index,
 			getPath: () => myPath,
 			getBoxEl: () => boxEl,
-			// The effective state, so a transiently-opened section actually mounts and
-			// measures its body.
+			// The state on screen, so a section opened only in reading mode still mounts
+			// and measures its body.
 			isCollapsed: () => !open
 		});
 
 	const reading = $derived(getPresentationMode() === 'reading');
 	const reader = createReaderDisclosure({ isDocumentOpen: () => documentOpen });
-	// Leaving reading mode discards the flip: with the bytes editable again, a view
-	// state they disagree with would be a live lie.
+	// Leaving reading mode discards the temporary state: with the bytes editable again, a
+	// view that disagrees with them would be showing something the document does not say.
 	$effect(() => {
 		if (!reading) reader.reset();
 	});
@@ -38,16 +37,17 @@
 
 	function commitDisclosure() {
 		const isOpen = open;
-		// Collapsing unmounts the body, orphaning a caret inside it, so move it to the summary
-		// in the commit's afterTick. Read before the commit: the toggle suppresses mousedown,
-		// so a mouse toggle leaves the caret in the body.
+		// Collapsing unmounts the body and orphans a caret inside it, so the commit puts it on the
+		// summary; the toggle suppresses mousedown, so a click leaves the caret where it was.
 		const pos = isOpen ? (containerApi.getCursorPosition?.() ?? null) : null;
 		const caretInBody = pos != null && pos.path[0] >= 1;
-		updateOwnMetadata({ open: !isOpen }, caretInBody ? () => containerApi.focus(0) : undefined);
+		updateOwnMetadata(
+			{ open: !isOpen },
+			caretInBody ? { caret: { path: [0], offset: 0 } } : undefined
+		);
 	}
 
-	// Reading mode gets the handler that cannot write, not one that declines to: this
-	// is the only mode read, and the toggle keeps working for a reader either way.
+	// Reading mode gets a handler that cannot write at all, so no toggle there becomes an edit.
 	const onToggle = $derived(reading ? reader.toggle : commitDisclosure);
 
 	export { containerApi };
@@ -67,7 +67,7 @@
 </div>
 
 <style>
-	/* Mirrors the admonition's rail gap and caret column so the two read as a family. */
+	/* Matches the admonition's left border and text column so the two look like a family. */
 	.details-block {
 		position: relative;
 		margin: 0.8em 0;
@@ -80,11 +80,11 @@
 	.details-toggle {
 		position: absolute;
 		left: 0.45em;
-		/* Anchors the button's em geometry to the editor font; without it the UA font-size
-		   shrinks the line-box math below and floats the caret above the summary title. */
+		/* Ties the button's em sizes to the editor font; without it the browser's default
+		   font-size shrinks the line box below and floats the arrow above the summary title. */
 		font: inherit;
-		/* Overlays the summary's first line box exactly (block padding + the leaf's 2px,
-		   one line-height tall), so flex-centering lands the caret on the title line. */
+		/* Sits exactly over the summary's first line (the block's padding plus the child's
+		   2px, one line-height tall), so centring lands the arrow on the title line. */
 		top: calc(0.15em + 2px);
 		width: 1.1em;
 		height: 1.6em;
@@ -116,8 +116,8 @@
 		border-radius: var(--radius-ui, 3px);
 	}
 
-	/* The summary leaf is promoted to a title row by CSS alone; it stays a real block
-	   inside `.block-list`, so selection and windowing treat it as an ordinary child. */
+	/* The summary is styled as a title row by CSS alone; it stays a real block inside
+	   `.block-list`, so selection and windowing treat it as an ordinary child. */
 	.details-block :global(.details-summary) {
 		font-weight: 600;
 	}

package/dist/plugins/details/details-disclosure.svelte.d.ts

@@ -1,12 +1,11 @@
 /**
- * The half of the `<details>` toggle that writes nothing: reading mode must let a
- * reader open a collapsed section without touching bytes, and these deps carry no
- * commit door, so no flip reachable from here can become an edit. Absent-by-default
- * rather than seeded on entry, so the document's own `open` shows through even for a
- * block windowed out at the moment of the flip. Scoped to the instance, so it is ephemeral.
+ * The half of the `<details>` toggle that writes nothing: in reading mode a user may open a
+ * collapsed section without touching bytes, and nothing handed in here can reach a commit.
+ * Starts unset rather than copying the document's `open`, so a block that was not mounted
+ * when the toggle happened still shows the document's own state. One per component instance.
  */
 export interface ReaderDisclosure {
-    /** The reader's flip if they made one, else the document's own state. */
+    /** What the user toggled it to, if they toggled it; otherwise the document's own state. */
     readonly open: boolean;
     toggle(): void;
     reset(): void;

package/dist/plugins/details/details-disclosure.svelte.js

@@ -1,9 +1,8 @@
 /**
- * The half of the `<details>` toggle that writes nothing: reading mode must let a
- * reader open a collapsed section without touching bytes, and these deps carry no
- * commit door, so no flip reachable from here can become an edit. Absent-by-default
- * rather than seeded on entry, so the document's own `open` shows through even for a
- * block windowed out at the moment of the flip. Scoped to the instance, so it is ephemeral.
+ * The half of the `<details>` toggle that writes nothing: in reading mode a user may open a
+ * collapsed section without touching bytes, and nothing handed in here can reach a commit.
+ * Starts unset rather than copying the document's `open`, so a block that was not mounted
+ * when the toggle happened still shows the document's own state. One per component instance.
  */
 export function createReaderDisclosure(deps) {
     let flipped = $state(null);
@@ -15,8 +14,8 @@ export function createReaderDisclosure(deps) {
             flipped = !(flipped ?? deps.isDocumentOpen());
         },
         reset() {
-            // Conditional: an unconditional write re-invalidates every reader of `open`
-            // on each pass of the effect that calls this.
+            // Guarded: writing unconditionally would invalidate everything that reads
+            // `open` on every pass of the effect that calls this.
             if (flipped !== null)
                 flipped = null;
         }

package/dist/plugins/details/details-kind.d.ts

@@ -1,17 +1,16 @@
 /**
- * `<details>` collapsible: the second reserved-chrome container consumer. The
- * `<summary>` is a real CST child at index 0 whose tags live in the container's own
- * raw, so `strip(raw)` diverges from `serialize(children)`, hence `'opaque'` (raw
- * authoritative, exempt from `checkStaleRaw`). Non-canonical `<details …>` declines
- * to the built-in htmlBlock.
+ * The `<details>` collapsible. Its `<summary>` is a real CST child at index 0, but the tags
+ * around it live in the container's own raw, so `strip(raw)` differs from
+ * `serialize(children)`: hence `'opaque'`, where raw is authoritative and `checkStaleRaw` is
+ * skipped. A `<details …>` written any other way is left to the built-in htmlBlock.
  */
 import { type CstNode } from '../../plugin';
 export declare const DETAILS = "details";
 export declare const DETAILS_SUMMARY = "details-summary";
 export interface DetailsMetadata {
     open: boolean;
-    /** One captured ending governs all three chrome lines: a well-formed document has
-     *  uniform endings, so the rebuild reproduces them byte-identically. */
+    /** One captured ending is used for all three tag lines: a well-formed document has
+     *  uniform endings, so the rebuild reproduces them byte for byte. */
     lineEnding: string;
     /** False for a document-final details with no trailing newline, so the rebuild
      *  does not add one. */

package/dist/plugins/details/details-kind.js

@@ -1,11 +1,10 @@
 /**
- * `<details>` collapsible: the second reserved-chrome container consumer. The
- * `<summary>` is a real CST child at index 0 whose tags live in the container's own
- * raw, so `strip(raw)` diverges from `serialize(children)`, hence `'opaque'` (raw
- * authoritative, exempt from `checkStaleRaw`). Non-canonical `<details …>` declines
- * to the built-in htmlBlock.
+ * The `<details>` collapsible. Its `<summary>` is a real CST child at index 0, but the tags
+ * around it live in the container's own raw, so `strip(raw)` differs from
+ * `serialize(children)`: hence `'opaque'`, where raw is authoritative and `checkStaleRaw` is
+ * skipped. A `<details …>` written any other way is left to the built-in htmlBlock.
  */
-import { chromeChild, containerClosure, declarePluginKind, declaredPluginKind, registerBlockKind, registerBlockOpener, registerChromeLeaf, setPluginMetadata, getPluginMetadata, parseContainerBody, serializeChildren, trimTrailingLineEnding, matchFenceOpen, matchFenceClose, htmlBlockTagLineMatcher, OPENER_PRIORITIES } from '../../plugin';
+import { chromeChild, containerClosure, declarePluginKind, declaredPluginKind, registerBlockKind, registerBlockOpener, registerChromeLeaf, setPluginMetadata, getPluginMetadata, parseContainerBody, serializeChildren, trimTrailingLineEnding, matchFenceOpen, findFenceCloser, htmlBlockTagLineMatcher, OPENER_PRIORITIES } from '../../plugin';
 export const DETAILS = 'details';
 export const DETAILS_SUMMARY = 'details-summary';
 const OPEN_LINE = /^<details( open)?>$/;
@@ -18,46 +17,36 @@ const canonicalTagLine = (text) => OPEN_LINE.test(text) ? 'open' : CLOSE_LINE.te
 /** What CommonMark hands to raw-HTML passthrough: a superset of the canonical form,
  *  and therefore of what closes the element in a browser. */
 const passthroughTagLine = htmlBlockTagLineMatcher('details');
-/**
- * A `</details>` inside a fenced code block is content on both sides of the round trip, so
- * neither the recognizer nor the escape may count it. Stateful, because the fence is.
- */
-function createTagScanner(tagLine) {
-    let fence = null;
-    return (text) => {
+/** Each tag line in `[from, end)` with its verdict, in order, until `visit` returns true; a fenced
+ *  code block's lines are skipped whole, since a `</details>` inside one is content. */
+function visitTagLines(lines, from, end, tagLine, visit) {
+    for (let i = from; i < end; i++) {
+        const fence = matchFenceOpen(lines[i].text);
         if (fence) {
-            if (matchFenceClose(text, fence.marker, fence.length))
-                fence = null;
-            return null;
-        }
-        const opened = matchFenceOpen(text);
-        if (opened) {
-            fence = { marker: opened.marker, length: opened.length };
-            return null;
+            const closer = findFenceCloser(lines, i + 1, end, fence);
+            i = closer === -1 ? end : closer;
+            continue;
         }
-        return tagLine(text);
-    };
+        if (visit(i, tagLine(lines[i].text)))
+            return;
+    }
 }
 function unpairedTagLines(lines, tagLine, settled) {
-    const classify = createTagScanner(tagLine);
     const openIndices = [];
     const unpaired = [];
-    for (let i = 0; i < lines.length; i++) {
-        const verdict = classify(lines[i]);
+    const texts = lines.map((text) => ({ text }));
+    visitTagLines(texts, 0, texts.length, tagLine, (i, verdict) => {
         if (settled.has(i))
-            continue;
+            return;
         if (verdict === 'open')
             openIndices.push(i);
         else if (verdict === 'close' && openIndices.pop() === undefined)
             unpaired.push(i);
-    }
+    });
     return [...unpaired, ...openIndices];
 }
-/**
- * Two accountings, because the recognizer and a browser disagree about what a tag line is,
- * and only the fixpoint leaves neither renderer holding a stray. Terminates because every
- * round escapes a line and escaping never mints a tag.
- */
+/** Repeats until nothing changes, since this recognizer and a browser disagree on what a tag line
+ *  is; every round escapes a line and escaping never creates a tag, so it ends. */
 function strayTagLines(lines) {
     const escaped = new Set();
     for (;;) {
@@ -86,8 +75,8 @@ function strayEscapePoints(raw) {
         .sort((a, b) => a - b)
         .map((i) => starts[i] + texts[i].indexOf('<'));
 }
-/** Renders as the literal glyph in a paragraph, in an html block's passthrough, and on
- *  GitHub alike, while matching no tag line. */
+/** Renders as a literal `<` in a paragraph, in an html block's passthrough, and on GitHub
+ *  alike, while matching no tag line. */
 const ESCAPED_LT = '&lt;';
 function escapeStrayDetailsTags(raw) {
     const points = strayEscapePoints(raw);
@@ -101,8 +90,8 @@ function escapeStrayDetailsTags(raw) {
     }
     return out + raw.slice(cursor);
 }
-/** {@link escapeStrayDetailsTags}'s caret image: each escape ahead of the caret pushes
- *  it by the entity's growth. */
+/** Where {@link escapeStrayDetailsTags} leaves the caret: each escape before it pushes the
+ *  caret along by the characters the entity adds. */
 function mapStrayEscapeOffset(raw, offset) {
     const grown = ESCAPED_LT.length - 1;
     return strayEscapePoints(raw).reduce((at, point) => (point < offset ? at + grown : at), offset);
@@ -127,10 +116,13 @@ export function registerDetailsKind() {
     const details = declarePluginKind(DETAILS);
     const detailsSummary = declarePluginKind(DETAILS_SUMMARY);
     registerBlockKind(details, {
+        label: 'Details',
+        dragLabel: 'Details',
         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 at either edge for the caret to step into, so both
+        // edges take the gap caret.
         gapEdges: 'both',
         container: {
             contract: 'opaque',
@@ -141,10 +133,7 @@ export function registerDetailsKind() {
                 isCollapsed: (node) => !getPluginMetadata(node)?.open,
                 expandPatch: () => ({ open: true })
             },
-            unwrapRole: {
-                firstChildBackspace: 'keep-reserved-chrome',
-                middleChildBackspace: 'default-merge'
-            },
+            unwrapRole: { middleChildBackspace: 'default-merge' },
             bodyWrite: { normalize: escapeStrayDetailsTags, mapOffset: mapStrayEscapeOffset }
         },
         conformanceFixture: '<details>\n<summary>Title</summary>\n\nbody\n\n</details>\n',
@@ -169,12 +158,12 @@ export function registerDetailsKind() {
             }
         })
     });
-    registerChromeLeaf(detailsSummary, { blockClass: 'details-summary' });
+    registerChromeLeaf(detailsSummary, { label: 'Summary', blockClass: 'details-summary' });
     registerBlockOpener(details, {
-        // Slots into the gap just below htmlBlock, which else claims `<details>` as a type-6 block.
+        // Just below htmlBlock, which would otherwise take `<details>` as a type-6 block.
         priority: OPENER_PRIORITIES.htmlBlock - 5,
         // Redundant with htmlBlock's type-6 interrupt, which details wins on re-dispatch; kept
-        // so the opener's paragraph behavior does not depend on that priority ordering.
+        // so this opener's paragraph behavior does not depend on that priority order.
         interruptsParagraph: (line) => OPEN_LINE.test(line),
         tryOpen(ctx) {
             const openMatch = ctx.line.text.match(OPEN_LINE);
@@ -189,20 +178,13 @@ export function registerDetailsKind() {
             // Depth-counted so nested details recurse via parse rather than closing early.
             let depth = 1;
             let closeIdx = -1;
-            const classify = createTagScanner(canonicalTagLine);
-            for (let i = summaryIdx + 1; i < ctx.end; i++) {
-                const tag = classify(ctx.lines[i].text);
-                if (tag === 'open') {
+            visitTagLines(ctx.lines, summaryIdx + 1, ctx.end, canonicalTagLine, (i, tag) => {
+                if (tag === 'open')
                     depth++;
-                }
-                else if (tag === 'close') {
-                    depth--;
-                    if (depth === 0) {
-                        closeIdx = i;
-                        break;
-                    }
-                }
-            }
+                else if (tag === 'close' && --depth === 0)
+                    closeIdx = i;
+                return closeIdx !== -1;
+            });
             if (closeIdx === -1)
                 return null; // unterminated declines to htmlBlock
             const bodyText = ctx.lines
@@ -210,7 +192,10 @@ export function registerDetailsKind() {
                 .map((l) => l.raw)
                 .join('');
             // A fresh parse entry, so the body's own line 0 must not read as the document top.
-            const body = parseContainerBody(bodyText, BODY_WRAP, { scope: 'fragment' });
+            const body = parseContainerBody(bodyText, BODY_WRAP, {
+                scope: 'fragment',
+                grammar: ctx.grammar
+            });
             const raw = ctx.lines
                 .slice(ctx.index, closeIdx + 1)
                 .map((l) => l.raw)

package/dist/plugins/emoji/emoji-recognizer.d.ts

@@ -6,13 +6,10 @@
  */
 import { type InlineNode, type PluginInlineKind } from '../../plugin';
 export declare const EMOJI_KIND = "emoji";
-/**
- * Claims only on a table hit, carrying the glyph on `decoded` (the decoded-entity mold).
- * The name is sliced only once a closing colon has bounded a non-empty run, so the common
- * decline paths allocate nothing.
- */
+/** Matches only a shortcode in the table, carrying the glyph on `decoded` as an entity does; the
+ *  name is sliced only once a closing colon bounds it, so a miss allocates nothing. */
 export declare function recognizeEmoji(raw: string, pos: number, end: number, kind: PluginInlineKind): InlineNode | null;
-/** `user-select: none` keeps the glyph atomic to the caret; set inline because a
- *  `buildWidget` island has no style scope. */
+/** `user-select: none` keeps the caret from entering the glyph; set inline because a widget
+ *  built by `buildWidget` has no scoped stylesheet. */
 export declare function buildEmojiWidget(node: InlineNode): HTMLSpanElement;
 export declare function registerEmoji(): void;

package/dist/plugins/emoji/emoji-recognizer.js

@@ -4,7 +4,7 @@
  * untouched; the glyph is only what the widget paints. Recognition is gated on
  * registration, so with the plugin absent `:smile:` is ordinary prose.
  */
-import { INLINE_PRIORITIES, declarePluginInlineKind, isInlineKindDeclared, mintWidgetShell, registerInlineSyntax, registerInlineWidgetKind } from '../../plugin';
+import { INLINE_PRIORITIES, declarePluginInlineKind, mintWidgetShell, registerInlineSyntax, registerInlineWidgetKind } from '../../plugin';
 import { EMOJI_TABLE } from './emoji-table';
 export const EMOJI_KIND = 'emoji';
 // The gemoji alphabet: uppercase is excluded to match GitHub, and excluding the
@@ -17,11 +17,8 @@ function isShortcodeChar(code) {
         code === 0x2d // -
     );
 }
-/**
- * Claims only on a table hit, carrying the glyph on `decoded` (the decoded-entity mold).
- * The name is sliced only once a closing colon has bounded a non-empty run, so the common
- * decline paths allocate nothing.
- */
+/** Matches only a shortcode in the table, carrying the glyph on `decoded` as an entity does; the
+ *  name is sliced only once a closing colon bounds it, so a miss allocates nothing. */
 export function recognizeEmoji(raw, pos, end, kind) {
     let i = pos + 1;
     while (i < end && raw.charCodeAt(i) !== 0x3a) {
@@ -36,8 +33,8 @@ export function recognizeEmoji(raw, pos, end, kind) {
         return null;
     return { kind, start: pos, end: i + 1, decoded: glyph };
 }
-/** `user-select: none` keeps the glyph atomic to the caret; set inline because a
- *  `buildWidget` island has no style scope. */
+/** `user-select: none` keeps the caret from entering the glyph; set inline because a widget
+ *  built by `buildWidget` has no scoped stylesheet. */
 export function buildEmojiWidget(node) {
     const shell = mintWidgetShell('md-emoji-widget', node);
     shell.textContent = node.decoded ?? '';
@@ -45,14 +42,10 @@ export function buildEmojiWidget(node) {
     return shell;
 }
 export function registerEmoji() {
-    // Keyed on the kind registry, not a module latch, so the platform reset that clears
-    // the inline registries also clears this guard.
-    if (isInlineKindDeclared(EMOJI_KIND))
-        return;
     const kind = declarePluginInlineKind(EMOJI_KIND);
     registerInlineSyntax(':', (raw, pos, end) => recognizeEmoji(raw, pos, end, kind), {
-        // The register-once grain forbids a second `:` registration at the plugin rung, so the
-        // +10 is what lets emoji share the trigger with the directive text tier.
+        // Registering `:` twice at the same priority is refused, so the +10 is what lets emoji
+        // share the trigger with the directive text handler.
         priority: INLINE_PRIORITIES.plugin + 10
     });
     registerInlineWidgetKind(kind, {