@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/plugins/latex/register.d.ts

@@ -1,19 +1,18 @@
 /**
- * `renderer` is required because there is no baked-in default engine; `katexRenderer`
- * is the one-import path. The plugin unit installs this setup once per process, so it
- * runs unguarded.
+ * `katexRenderer` is the one-import way to supply `renderer`; without one, each formula shows its
+ * source. The plugin installs this setup once per process, so it runs unguarded.
  */
 import { type EditorPlugin } from '../../plugin';
 import { type MathRenderer } from './math-renderer';
 import { type MathBlockLayout } from './math-layout';
 export interface LatexPluginOptions {
-    renderer: MathRenderer;
-    /**
-     * How a `$$` block opens for editing: `split` (source beside the preview, the default),
-     * `stacked` (preview below), or `source` (no preview). Definition-time, so it is the
-     * bare-install default; an editor's `{ plugin, options: { blockLayout } }` entry overrides it
-     * per instance. The block's own toggle cycles from whichever applies.
-     */
+    renderer?: MathRenderer;
+    /** How a `$$` block opens for editing (`math-layout.ts`); an editor's
+     *  `{ plugin, options: { blockLayout } }` entry overrides it. */
     blockLayout?: MathBlockLayout;
 }
-export declare function latexPlugin(options: LatexPluginOptions): EditorPlugin;
+/** What one editor reads: the renderer is process-wide, so only the layout varies per editor. */
+export interface LatexEditorOptions {
+    blockLayout: MathBlockLayout;
+}
+export declare function latexPlugin(options?: LatexPluginOptions): EditorPlugin;

package/dist/plugins/latex/register.js

@@ -1,25 +1,39 @@
 /**
- * `renderer` is required because there is no baked-in default engine; `katexRenderer`
- * is the one-import path. The plugin unit installs this setup once per process, so it
- * runs unguarded.
+ * `katexRenderer` is the one-import way to supply `renderer`; without one, each formula shows its
+ * source. The plugin installs this setup once per process, so it runs unguarded.
  */
-import { definePlugin, registerBlockComponent, defineBlockComponent, declaredPluginKind } from '../../plugin';
+import { definePlugin, registerBlockComponent, defineBlockComponent, declaredPluginKind, registerInsertEntry } from '../../plugin';
 import { registerMathInline, registerMathBlock, MATH_BLOCK, MATH_FENCE } from './latex-kind';
-import { setMathRenderer } from './math-renderer';
+import { mathSlot } from './math-renderer';
 import { isMathBlockLayout } from './math-layout';
 import BlockMath from './BlockMath.svelte';
-export function latexPlugin(options) {
-    const blockLayout = isMathBlockLayout(options.blockLayout) ? options.blockLayout : 'split';
+export function latexPlugin(options = {}) {
+    const { renderer } = options;
     return definePlugin({
         name: 'latex',
+        defaults: {
+            blockLayout: isMathBlockLayout(options.blockLayout) ? options.blockLayout : 'split'
+        },
+        // An unknown layout keeps the default rather than breaking the block.
+        parseOptions(raw) {
+            const blockLayout = raw?.blockLayout;
+            return isMathBlockLayout(blockLayout) ? { blockLayout } : {};
+        },
         setup() {
-            setMathRenderer(options.renderer);
+            mathSlot.set(renderer ? ({ source, display }, { theme }) => renderer(source, { display, theme }) : null);
             registerMathInline();
-            // registerMathBlock co-registers the ```math fence kind; both render through BlockMath.
+            // registerMathBlock also registers the ```math fence kind; both render through BlockMath.
             registerMathBlock();
-            const blockMath = defineBlockComponent(BlockMath, () => ({ blockLayout }));
+            const blockMath = defineBlockComponent(BlockMath);
             registerBlockComponent(declaredPluginKind(MATH_BLOCK), blockMath);
             registerBlockComponent(declaredPluginKind(MATH_FENCE), blockMath);
+            registerInsertEntry({
+                id: 'math',
+                label: 'Math block',
+                icon: 'sigma',
+                keywords: ['math', 'latex', 'equation', 'tex'],
+                markdown: '$$\n\n$$\n'
+            });
         }
     });
 }

package/dist/plugins/latex/renderer.d.ts

@@ -1,13 +1,12 @@
 /**
- * The engine adapter behind the `@voithos-labs/aragonite/plugins/latex/renderer` subpath. Importing
- * it is how a consumer opts into `katex`, an optional peer the engine-free core never
- * pulls.
+ * The KaTeX adapter behind the `@voithos-labs/aragonite/plugins/latex/renderer` subpath.
+ * Importing it is how a consumer opts into `katex`, an optional peer dependency nothing else
+ * pulls in.
  */
 import 'katex/dist/katex.min.css';
-import type { MathRenderer } from './math-renderer';
-/**
- * `throwOnError: false` keeps a malformed formula from crashing the editor; its fallback is
- * swapped for the source painted as an error — red, in the code face, the parser's message on
- * hover — so a broken formula reads as what the author typed, not as a sentence about it.
- */
-export declare const katexRenderer: MathRenderer;
+import { type MathRender } from './math-renderer';
+/** `throwOnError: false` paints a malformed formula as `mathErrorNode` rather than throwing.
+ *  KaTeX draws no colors of its own, so it has no use for the theme. */
+export declare const katexRenderer: (source: string, { display }: {
+    display: boolean;
+}) => MathRender;

package/dist/plugins/latex/renderer.js

@@ -1,17 +1,15 @@
 /**
- * The engine adapter behind the `@voithos-labs/aragonite/plugins/latex/renderer` subpath. Importing
- * it is how a consumer opts into `katex`, an optional peer the engine-free core never
- * pulls.
+ * The KaTeX adapter behind the `@voithos-labs/aragonite/plugins/latex/renderer` subpath.
+ * Importing it is how a consumer opts into `katex`, an optional peer dependency nothing else
+ * pulls in.
  */
 import katex from 'katex';
-// Rides this module so a consumer wiring the adapter cannot forget it: `htmlAndMathml` emits
-// a `.katex-mathml` a11y tree this CSS clips to 1px, and unloaded every equation paints twice.
+// Imported here so a consumer wiring the adapter cannot forget it: `htmlAndMathml` emits a
+// `.katex-mathml` accessibility tree this CSS clips to 1px; without it every equation paints twice.
 import 'katex/dist/katex.min.css';
-/**
- * `throwOnError: false` keeps a malformed formula from crashing the editor; its fallback is
- * swapped for the source painted as an error — red, in the code face, the parser's message on
- * hover — so a broken formula reads as what the author typed, not as a sentence about it.
- */
+import { mathErrorNode } from './math-renderer';
+/** `throwOnError: false` paints a malformed formula as `mathErrorNode` rather than throwing.
+ *  KaTeX draws no colors of its own, so it has no use for the theme. */
 export const katexRenderer = (source, { display }) => {
     const container = document.createElement('span');
     container.innerHTML = katex.renderToString(source, {
@@ -22,20 +20,7 @@ export const katexRenderer = (source, { display }) => {
     const errorSpan = container.querySelector('.katex-error');
     if (errorSpan) {
         const message = (errorSpan.getAttribute('title') ?? 'invalid LaTeX').replace(/^ParseError:\s*/, '');
-        return { dom: buildErrorNode(source, message), error: message };
+        return { dom: mathErrorNode(source, message), error: message };
     }
     return { dom: container };
 };
-function buildErrorNode(source, message) {
-    const span = document.createElement('span');
-    span.className = 'math-error';
-    span.textContent = source;
-    span.title = message;
-    // Inline style rather than a stylesheet: the span lands inside any prose block, where no
-    // plugin sheet is guaranteed to be mounted.
-    span.style.color = 'var(--color-error, #d03025)';
-    span.style.fontFamily = 'var(--font-code, ui-monospace, monospace)';
-    span.style.fontSize = '0.9em';
-    span.style.cursor = 'help';
-    return span;
-}

package/dist/plugins/mermaid/MermaidBlock.svelte

@@ -1,25 +1,26 @@
 <script lang="ts">
-	// Render-primary on the public seam: `createContainerBlock` supplies the metadata
-	// commit and kind-command keydown, but the body renders the diagram, with no
-	// BlockList. Editing swaps in a plugin-owned textarea whose draft commits through
-	// the metadata seam as one undoable entry.
+	// Render-primary, built on the public API: `createContainerBlock` supplies the metadata
+	// commit and the keydown for kind commands, but the body renders the diagram, with no
+	// BlockList. Editing swaps in a textarea this plugin owns, whose text commits through the
+	// metadata update as one undo entry.
 	import { tick } from 'svelte';
 	import {
 		createContainerBlock,
 		getPluginMetadata,
 		trimTrailingLineEnding,
 		normalizeLineEndings,
+		POINTER_GESTURE_ATTR,
 		type NodeView
 	} from '../../plugin';
 	import { joinMermaidBody, type MermaidMetadata } from './mermaid-kind';
-	import { hasMermaidRenderer, renderMermaid, type MermaidRenderResult } from './mermaid-renderer';
+	import { mermaidSlot, type MermaidRenderResult } from './mermaid-renderer';
 
 	let { node, index, myPath = [] }: { node: NodeView; index: number; myPath?: number[] } = $props();
 
 	let boxEl: HTMLElement | undefined = $state();
 
-	// Every steady state carries a focus surface — the edit textarea included, so a broken or
-	// empty diagram is an arrow stop and a recovery entry point rather than a caret trap.
+	// Every state has something focusable, the edit textarea included, so a broken or empty
+	// diagram is a stop for the arrow keys and a way back in rather than a caret trap.
 	function focusSurfaceEl(): HTMLElement | null {
 		return (
 			boxEl?.querySelector<HTMLElement>('.mermaid-source, .mermaid-viewport, .mermaid-surface') ??
@@ -46,15 +47,15 @@
 		commandHooks: () => ({ openEdit, openFocusView })
 	});
 
-	// The factory routes whole-block focus, delete, traversal and reorder, and carries
-	// the `measurePartialRects` the overlays paint off: there are no child hosts here.
+	// The factory handles whole-block focus, delete, traversal and reorder, and provides the
+	// `measurePartialRects` the overlays are painted from: there are no child blocks here.
 	export { containerApi };
 
 	const code = $derived(getPluginMetadata<MermaidMetadata>(node)?.code ?? '');
 	const displayCode = $derived(trimTrailingLineEnding(code));
 
-	// An empty diagram has no picture to draw and the engine rejects it, so its natural view is
-	// the edit surface; reading mode, which writes no bytes, gets a placeholder instead.
+	// An empty diagram has no picture to draw and mermaid rejects it, so it opens straight into
+	// the textarea; reading mode, which writes no bytes, gets a placeholder instead.
 	const isEmpty = $derived(displayCode.trim() === '');
 	const isReading = $derived(getPresentationMode() === 'reading');
 
@@ -63,15 +64,15 @@
 	let rendered = $state<MermaidRenderResult | null>(null);
 	$effect(() => {
 		const current = code;
-		// Reading the theme here is what subscribes this effect to a flip, which has to
-		// redraw because the engine writes colors into the SVG.
+		// Reading the theme here is what makes this effect re-run when the theme changes, and
+		// it must redraw because mermaid writes colors into the SVG.
 		const theme = getTheme();
-		if (isEmpty || !hasMermaidRenderer()) return;
+		if (isEmpty || !mermaidSlot.configured) return;
 		let stale = false;
-		void renderMermaid(current, theme).then(async (result) => {
+		void mermaidSlot.render(current, { theme }).then(async (result) => {
 			if (stale) return;
-			// A swap replaces the rendered surface alone, so only focus INSIDE it is re-handed:
-			// the editor hidden input host and the toolbar are box children and survive untouched.
+			// A redraw replaces only the rendered element, so only focus inside it is handed back:
+			// the editor's hidden input and the toolbar are children of the box and survive.
 			const hadFocus = focusSurfaceEl()?.contains(document.activeElement) ?? false;
 			rendered = result;
 			if (hadFocus) {
@@ -87,7 +88,7 @@
 	const surfaceState = $derived(
 		isEmpty
 			? 'empty'
-			: !hasMermaidRenderer()
+			: !mermaidSlot.configured
 				? 'no-renderer'
 				: rendered?.error
 					? 'error'
@@ -143,9 +144,12 @@
 	const view = createPanZoom();
 	const overlayView = createPanZoom();
 
-	// Armed by focus, so an unfocused diagram hijacks neither the page nor the editor's own drag.
-	// Tracked rather than probed: the editor reads the same fact as markup, so there is one value.
+	// Turned on by focus, so an unfocused diagram hijacks neither the page nor the editor's own
+	// drag. The markup attribute is written from this one value.
 	let gestureArmed = $state(false);
+	// The attribute that tells the editor's pointer handling a drag here is the diagram's own.
+	const viewportGesture = $derived({ [POINTER_GESTURE_ATTR]: gestureArmed ? '' : undefined });
+	const overlayGesture = { [POINTER_GESTURE_ATTR]: '' };
 
 	function onViewportWheel(e: WheelEvent): void {
 		if (!gestureArmed || !(e.ctrlKey || e.metaKey)) return;
@@ -160,15 +164,15 @@
 	}
 
 	function onOverlayWheel(e: WheelEvent): void {
-		// A dedicated zoom surface with nothing behind to scroll, so unlike the
-		// in-document view a bare wheel zooms.
+		// A zoom view of its own with nothing behind it to scroll, so unlike the in-document
+		// view a plain wheel zooms.
 		e.preventDefault();
 		e.stopPropagation();
 		overlayView.zoomBy(e.deltaY);
 	}
 
-	// One click contract for the viewport and the non-rendered cards, so dblclick stays
-	// the recovery path out of a broken diagram.
+	// The viewport and the cards that show no picture answer clicks the same way, so a double
+	// click stays the way out of a broken diagram.
 	function onSurfacePointerDown(e: PointerEvent): void {
 		e.stopPropagation();
 	}
@@ -218,11 +222,11 @@
 		// there too, so this closes the command path.
 		if (isReading) return;
 		if (!editing) seedDraft();
-		// Captured BEFORE the flip: the card reaches its fitted height only after mounting, and
-		// a scrollport at the document's end clamps against the short layout in between.
+		// Captured before the swap: the card reaches its fitted height only after mounting, and
+		// a scroll container at the document's end clamps against the short layout in between.
 		const restoreScroll = captureScrollPosition();
 		editRequested = true;
-		void restoreScroll().then(() => textareaEl?.focus());
+		void restoreScroll().then(() => textareaEl?.focus({ preventScroll: true }));
 	}
 
 	function cancelEdit(): void {
@@ -241,10 +245,12 @@
 		// an untouched CRLF block must not rewrite its bytes on blur.
 		if (value === normalizeLineEndings(editSeed)) return;
 		const lineEnding = getPluginMetadata<MermaidMetadata>(node)?.openerLineEnding ?? '\n';
-		updateOwnMetadata({ code: joinMermaidBody(value, lineEnding) });
-		// Only a keyboard commit refocuses; a blur commit must not yank focus back from
-		// wherever the user clicked.
-		if (refocus) refocusBlock();
+		// Only a keyboard commit puts the caret back on the block; a blur commit must not yank
+		// focus back from wherever the user clicked.
+		updateOwnMetadata(
+			{ code: joinMermaidBody(value, lineEnding) },
+			refocus ? { caret: { path: [], offset: 0 } } : undefined
+		);
 	}
 
 	// Logical lines, not visual: the box carries no editor caret geometry, so the newlines
@@ -271,8 +277,8 @@
 			e.preventDefault();
 			cancelEdit();
 		} else if (atEditBoxEdge(e.key) && moveFocusOut(e)) {
-			// Focus leaves the box, so `focusout` commits the draft: the arrow exit forks
-			// nothing off the blur path.
+			// Focus leaves the box, so `focusout` commits the text: leaving by arrow key takes
+			// the same path as a blur.
 			e.preventDefault();
 		} else if (e.key === 'Tab') {
 			// Escape is the exit, so Tab indents in place. execCommand inserts through the
@@ -338,7 +344,7 @@
 			<!-- svelte-ignore a11y_no_noninteractive_tabindex -->
 			<div
 				class="mermaid-viewport"
-				data-pointer-gesture={gestureArmed ? '' : undefined}
+				{...viewportGesture}
 				tabindex="0"
 				role="img"
 				aria-label="Mermaid diagram"
@@ -354,8 +360,8 @@
 				</div>
 			</div>
 		{:else}
-			<!-- {#key} keeps the per-arm remount: a state flip replaces the surface element,
-			     and its focus/blur timing with it. -->
+			<!-- {#key} remounts once per state: a change of state replaces the element, and
+			     its focus and blur timing with it. -->
 			{#key surfaceState}
 				<!-- svelte-ignore a11y_no_noninteractive_tabindex -->
 				<div
@@ -367,7 +373,7 @@
 					ondblclick={onSurfaceDblClick}
 				>
 					{#if surfaceState === 'empty'}
-						<!-- Reading mode only: everywhere else an empty diagram renders its edit surface. -->
+						<!-- Reading mode only: everywhere else an empty diagram opens its textarea. -->
 						<div class="mermaid-empty">Empty diagram</div>
 					{:else if surfaceState === 'no-renderer'}
 						<pre class="mermaid-static">{displayCode}</pre>
@@ -401,7 +407,7 @@
 			</div>
 			<div
 				class="mermaid-overlay-viewport"
-				data-pointer-gesture
+				{...overlayGesture}
 				onwheel={onOverlayWheel}
 				onpointerdown={(e) => {
 					e.stopPropagation();
@@ -442,8 +448,8 @@
 		background: var(--color-bg-secondary, rgba(128, 128, 128, 0.12));
 	}
 
-	/* Revealed on hover/focus so the diagram carries no chrome at rest (SearchBar's
-	   elevated-surface + ghost-button convention). */
+	/* Shown on hover or focus so the diagram has no buttons over it at rest, following
+	   SearchBar's raised panel and plain buttons. */
 	.mermaid-toolbar {
 		position: absolute;
 		top: 6px;
@@ -467,7 +473,7 @@
 		pointer-events: auto;
 	}
 
-	/* Reading mode drops the edit affordance; Focus/Reset are view-only and stay. */
+	/* Reading mode drops the edit button; Focus and Reset only change the view, so they stay. */
 	:global([data-presentation='reading']) .mermaid-toolbar :global([data-testid='mermaid-edit']) {
 		display: none;
 	}
@@ -502,8 +508,8 @@
 		outline: none;
 	}
 
-	/* Only a focused block pans, so only then does the viewport hint with the grab cursor.
-	   `:focus-within`: whole-block focus lands on the editor's hidden input host beside it. */
+	/* Only a focused block pans, so only then does the viewport show the grab cursor.
+	   `:focus-within`, because whole-block focus goes to the editor's hidden input beside it. */
 	.mermaid-block:focus-within .mermaid-viewport {
 		cursor: grab;
 	}
@@ -514,8 +520,8 @@
 		justify-content: center;
 	}
 
-	/* Deltas over the shared .md-source-surface (editor.css). Height is written by the
-	   fit-to-content effect; `overflow-y: hidden` keeps the grow visible instead of scrolled. */
+	/* Only the differences from the shared .md-source-surface (editor.css). Height is written by
+	   the fit-to-content effect; `overflow-y: hidden` lets the box grow rather than scroll. */
 	.mermaid-source {
 		padding: 8px;
 		overflow-y: hidden;

package/dist/plugins/mermaid/index.js

@@ -1,3 +1,3 @@
-// Importing this pulls no rendering engine; the adapter lives at the `/renderer` subpath.
+// Importing this pulls in no renderer; the adapter lives at the `/renderer` subpath.
 export { mermaidPlugin } from './register';
 export { MERMAID } from './mermaid-kind';

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

@@ -1,7 +1,7 @@
 /**
- * The reference whole-block container, on public registration seams only: an opaque
+ * The worked example of a whole-block container, using public registration only: an opaque
  * container with no children, its diagram code in typed metadata, so an
- * `updateOwnMetadata({ code })` commit is the whole edit path. Uninstall safety is by
+ * `updateOwnMetadata({ code })` commit is the whole edit path. Uninstalling is safe by
  * construction: without this opener the same bytes parse as plain `fencedCode`.
  */
 import { type CstNode } from '../../plugin';
@@ -25,11 +25,8 @@ export interface MermaidMetadata {
  * ending put back on every body line. An emptied body commits as `''`, no stray line.
  */
 export declare function joinMermaidBody(draft: string, lineEnding: string): string;
-/**
- * The opener's inverse, and the byte path every code edit rides. The body is a metadata string
- * this kind never re-parses, so the fence is sized against it here — a diagram line that reads as
- * this block's closer would otherwise truncate the block on its next load.
- */
+/** The opener's inverse, which every code edit goes through; the fence is sized against the body
+ *  here, since a diagram line reading as the closer would cut the block short on reload. */
 export declare function rebuildMermaidRaw(node: CstNode): void;
 export interface MermaidUiHooks {
     openEdit(): void;

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

@@ -1,18 +1,15 @@
 /**
- * The reference whole-block container, on public registration seams only: an opaque
+ * The worked example of a whole-block container, using public registration only: an opaque
  * container with no children, its diagram code in typed metadata, so an
- * `updateOwnMetadata({ code })` commit is the whole edit path. Uninstall safety is by
+ * `updateOwnMetadata({ code })` commit is the whole edit path. Uninstalling is safe by
  * construction: without this opener the same bytes parse as plain `fencedCode`.
  */
-import { declarePluginKind, registerBlockKind, registerBlockOpener, registerBlockCommand, setPluginMetadata, getPluginMetadata, matchFenceOpen, matchFenceClose, escalatedFenceLength, OPENER_PRIORITIES } from '../../plugin';
+import { declarePluginKind, registerBlockKind, registerBlockOpener, registerBlockCommand, setPluginMetadata, getPluginMetadata, matchFenceInfo, escalatedFenceLength, fenceRawWrite, fenceShapeOfRaw, scanFence, OPENER_PRIORITIES } from '../../plugin';
 export const MERMAID = 'mermaid';
 // ── Fence grammar ─────────────────────────────────────────────────────────────
-// The barrel's built-in matcher, gated on the info string's first word, so the
-// CommonMark fence rules stay the editor's and never become a plugin copy.
-function matchMermaidFence(text) {
-    const fence = matchFenceOpen(text);
-    return fence && fence.info.split(/\s+/)[0] === MERMAID ? fence : null;
-}
+// The editor's own fence matcher, filtered on the info string's first word, so the CommonMark
+// fence rules stay in one place and never become a plugin's copy of them.
+const matchMermaidFence = matchFenceInfo(MERMAID);
 /**
  * The edit textarea normalizes to LF, so a CRLF-authored diagram needs its authored
  * ending put back on every body line. An emptied body commits as `''`, no stray line.
@@ -22,11 +19,8 @@ export function joinMermaidBody(draft, lineEnding) {
         return '';
     return draft.replaceAll('\n', lineEnding) + lineEnding;
 }
-/**
- * The opener's inverse, and the byte path every code edit rides. The body is a metadata string
- * this kind never re-parses, so the fence is sized against it here — a diagram line that reads as
- * this block's closer would otherwise truncate the block on its next load.
- */
+/** The opener's inverse, which every code edit goes through; the fence is sized against the body
+ *  here, since a diagram line reading as the closer would cut the block short on reload. */
 export function rebuildMermaidRaw(node) {
     const meta = getPluginMetadata(node);
     if (!meta)
@@ -43,13 +37,10 @@ export function rebuildMermaidRaw(node) {
                 ? grownCloser(meta.closerRaw, marker, fenceLength)
                 : meta.closerRaw);
 }
-/**
- * Grow a verbatim closer line's run to `length`, keeping its indent, trailing spaces and line
- * ending. An unterminated block has no closer line and gains none: the parser reads it to the end
- * of input either way.
- */
+/** Grow a verbatim closer line's run to `length`, keeping its indent, trailing spaces and ending;
+ *  an unterminated block has no closer line and gains none. */
 function grownCloser(closerRaw, marker, length) {
-    const match = /^( {0,3})([`~]+)([\s\S]*)$/.exec(closerRaw);
+    const match = /^( {0,3})([`~]+)(.*)$/s.exec(closerRaw);
     if (!match)
         return closerRaw;
     return match[1] + marker.repeat(Math.max(match[2].length, length)) + match[3];
@@ -57,8 +48,8 @@ function grownCloser(closerRaw, marker, length) {
 // ── Registration ─────────────────────────────────────────────────────────────
 export function registerMermaidKind() {
     const mermaid = declarePluginKind(MERMAID);
-    // No default chord: the edit affordance is the button, and this command exists for
-    // consumer keymap bindings.
+    // No default key binding: the button is how you edit, and this command exists so a
+    // consumer can bind its own.
     registerBlockCommand(mermaid, 'mermaid.edit', (ctx) => {
         const hooks = ctx.hooks;
         if (!hooks)
@@ -74,25 +65,28 @@ export function registerMermaidKind() {
         return true;
     });
     registerBlockKind(mermaid, {
+        label: 'Diagram',
+        dragLabel: 'Diagram',
         // Backspace from the block below must never merge text into a diagram.
         mergeRole: 'not-mergeable',
         editable: true,
         supportsInline: false,
-        // ThematicBreak's focus-then-delete model: arrows stop on it, and a caret-adjacent
-        // Backspace focuses before a second press deletes.
+        // Focus first, then delete, as a thematic break does: arrows stop on it, and Backspace
+        // from the next block focuses it before a second Backspace deletes it.
         blockFocus: 'whole-block',
-        // Leading edge only, for the same reason as thematicBreak: its focused Enter already
-        // inserts a paragraph below.
+        // Leading edge only, for the same reason as a thematic break: pressing Enter while it
+        // is focused already inserts a paragraph below.
         gapEdges: 'before',
         container: {
-            // Raw is rebuilt from metadata alone, so it is exempt from the strip byte-check
-            // and guarded by the reparse + determinism probes instead.
+            // Raw is rebuilt from metadata alone, so the strip byte-check is skipped and the
+            // reparse and determinism checks cover it instead.
             contract: 'opaque',
             rebuildRaw: rebuildMermaidRaw
         },
-        // The char-based default would seed a rendered diagram at ~one line; the measured
-        // height supersedes this on mount.
+        // The character-count default would estimate a rendered diagram at about one line; the
+        // measured height replaces this on mount.
         estimateHeight: () => 320,
+        rawWrite: fenceRawWrite(fenceShapeOfRaw),
         keymap: [{ chord: 'Mod+M', command: focusCommand }],
         conformanceFixture: '```mermaid\ngraph TD\n```\n',
         closure: {
@@ -132,27 +126,16 @@ export function registerMermaidKind() {
         }
     });
     registerBlockOpener(mermaid, {
-        // `fencedCode` accepts every fence, ```mermaid included, so this must price ahead
-        // of that superset matcher rather than slot into a gap between built-ins.
+        // `fencedCode` accepts every fence, ```mermaid included, so this has to be tried
+        // before it rather than sit between two built-ins.
         priority: OPENER_PRIORITIES.fencedCode - 5,
         interruptsParagraph: (line) => matchMermaidFence(line) !== null,
         tryOpen(ctx) {
             const fence = matchMermaidFence(ctx.line.text);
             if (!fence)
                 return null;
-            let closeIdx = -1;
-            for (let i = ctx.index + 1; i < ctx.end; i++) {
-                if (matchFenceClose(ctx.lines[i].text, fence.marker, fence.length)) {
-                    closeIdx = i;
-                    break;
-                }
-            }
             // Unterminated consumes to end of input, like the built-in fence.
-            const codeEnd = closeIdx === -1 ? ctx.end : closeIdx;
-            const code = ctx.lines
-                .slice(ctx.index + 1, codeEnd)
-                .map((l) => l.raw)
-                .join('');
+            const scan = scanFence(ctx, fence);
             const node = {
                 kind: mermaid,
                 leadingTrivia: ctx.leadingTrivia,
@@ -160,17 +143,17 @@ export function registerMermaidKind() {
                 children: []
             };
             setPluginMetadata(node, {
-                code,
+                code: scan.body,
                 openerIndent: fence.indent,
                 fenceChar: fence.marker,
                 fenceLength: fence.length,
                 infoRaw: fence.infoRaw,
                 openerLineEnding: ctx.line.lineEnding,
-                closerRaw: closeIdx === -1 ? '' : ctx.lines[closeIdx].raw
+                closerRaw: scan.closer === -1 ? '' : ctx.lines[scan.closer].raw
             });
             // Raw comes from the rebuild, so opener and rebuild agree by construction.
             rebuildMermaidRaw(node);
-            return { node, consumed: (closeIdx === -1 ? ctx.end : closeIdx + 1) - ctx.index };
+            return { node, consumed: scan.consumed };
         }
     });
 }

package/dist/plugins/mermaid/mermaid-renderer.d.ts

@@ -1,13 +1,13 @@
 /**
- * The renderer-adapter seam: this module holds the injected renderer slot and the
- * memo, never the engine, which is confined to the `/renderer` subpath so it never
- * rides the core bundle. The engine travels by module because `MermaidBlock` mounts
- * with standard block props. No default: absent a renderer the code renders statically.
+ * Where the mermaid renderer is plugged in: `mermaidSlot` holds it and its cache, never mermaid
+ * itself, which stays behind the `/renderer` subpath so it never lands in the main bundle.
+ * `MermaidBlock` mounts with the standard block props, so it reads the renderer from here.
  */
+import { type RenderContext } from '../../plugin';
 /** What the editor knows at render time that the diagram text does not carry. */
 export interface MermaidRenderContext {
-    /** The engine paints colors into the SVG, so a stylesheet cannot retheme a drawn
-     *  diagram: the renderer has to draw for the theme. */
+    /** Mermaid paints colors into the SVG, so a stylesheet cannot retheme a drawn diagram:
+     *  the renderer has to draw for the theme. */
     theme: string;
 }
 /** Third parameter, so an existing `(code, id) => …` renderer stays assignable. */
@@ -16,13 +16,6 @@ export interface MermaidRenderResult {
     svg?: string;
     error?: string;
 }
-/** Exported so the eviction test derives its churn count from the real bound. */
-export declare const MERMAID_MEMO_CAP = 256;
-export declare function setMermaidRenderer(renderer: MermaidRenderer | null): void;
-export declare function hasMermaidRenderer(): boolean;
-/**
- * Theme belongs in the memo key rather than in a cache reset, so flipping back is a hit; an
- * SVG string needs no per-caller clone. A parse failure resolves to an `error` and caches
- * like a success. `theme` is required, so a caller cannot forget it and still compile.
- */
-export declare function renderMermaid(code: string, theme: string): Promise<MermaidRenderResult>;
+export declare const mermaidSlot: import("../../plugin").AsyncRendererSlot<string, MermaidRenderResult>;
+/** Mermaid needs a fresh element id per render, which the slot's `(code, ctx)` call leaves out. */
+export declare function adaptMermaidRenderer(renderer: MermaidRenderer): (code: string, ctx: RenderContext) => Promise<MermaidRenderResult>;