@voithos-labs/aragonite 0.10.3 → 0.10.7

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>;

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

@@ -1,35 +1,16 @@
 /**
- * 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 { createBoundedMemo } from '../../plugin';
-/** Exported so the eviction test derives its churn count from the real bound. */
-export const MERMAID_MEMO_CAP = 256;
-const newMemo = () => createBoundedMemo({ cap: MERMAID_MEMO_CAP });
-let activeRenderer = null;
-// The primitive owns no reset, so re-instantiation is how a renderer swap clears it.
-let memo = newMemo();
+import { createAsyncRendererSlot } from '../../plugin';
+export const mermaidSlot = createAsyncRendererSlot({
+    key: (code) => code,
+    missing: () => ({ error: 'renderer not configured' }),
+    failed: (_code, error) => ({ error: error instanceof Error ? error.message : String(error) })
+});
 let renderSeq = 0;
-export function setMermaidRenderer(renderer) {
-    activeRenderer = renderer;
-    memo = newMemo();
-}
-export function hasMermaidRenderer() {
-    return activeRenderer !== null;
-}
-/**
- * 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 function renderMermaid(code, theme) {
-    // NUL-joined so no (theme, code) pair can concatenate into another's key.
-    return memo(`${theme}\0${code}`, () => {
-        const renderer = activeRenderer;
-        return renderer
-            ? renderer(code, `aragonite-mermaid-${renderSeq++}`, { theme }).then((svg) => ({ svg }), (reason) => ({ error: reason instanceof Error ? reason.message : String(reason) }))
-            : Promise.resolve({ error: 'renderer not configured' });
-    });
+/** Mermaid needs a fresh element id per render, which the slot's `(code, ctx)` call leaves out. */
+export function adaptMermaidRenderer(renderer) {
+    return (code, { theme }) => renderer(code, `aragonite-mermaid-${renderSeq++}`, { theme }).then((svg) => ({ svg }));
 }

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

@@ -1,7 +1,7 @@
 /**
- * The renderer is injected because the engine is the consumer's dependency; absent
- * one the block renders its code statically. The plugin unit installs this setup once
- * per process, so it runs unguarded.
+ * The renderer is passed in because mermaid is the consumer's dependency; without one the
+ * block shows its code as plain text. The plugin installs this setup once per process, so it
+ * runs unguarded.
  */
 import { type EditorPlugin } from '../../plugin';
 import { type MermaidRenderer } from './mermaid-renderer';

package/dist/plugins/mermaid/register.js

@@ -1,11 +1,11 @@
 /**
- * The renderer is injected because the engine is the consumer's dependency; absent
- * one the block renders its code statically. The plugin unit installs this setup once
- * per process, so it runs unguarded.
+ * The renderer is passed in because mermaid is the consumer's dependency; without one the
+ * block shows its code as plain text. The plugin installs this setup once per process, so it
+ * runs unguarded.
  */
 import { definePluginBlock } from '../../plugin';
 import { registerMermaidKind, MERMAID } from './mermaid-kind';
-import { setMermaidRenderer } from './mermaid-renderer';
+import { adaptMermaidRenderer, mermaidSlot } from './mermaid-renderer';
 import MermaidBlock from './MermaidBlock.svelte';
 export function mermaidPlugin(options) {
     return definePluginBlock({
@@ -13,7 +13,7 @@ export function mermaidPlugin(options) {
         kind: MERMAID,
         component: MermaidBlock,
         register() {
-            setMermaidRenderer(options?.renderer ?? null);
+            mermaidSlot.set(options?.renderer ? adaptMermaidRenderer(options.renderer) : null);
             registerMermaidKind();
         }
     });

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

@@ -1,11 +1,11 @@
 /**
- * The engine adapter behind the `@voithos-labs/aragonite/plugins/mermaid/renderer` subpath, the
- * consumer half of the injection seam. The dynamic import keeps the engine off module
- * eval, so nothing touches `document` until a diagram actually renders.
+ * The mermaid adapter behind the `@voithos-labs/aragonite/plugins/mermaid/renderer` subpath,
+ * the half a consumer supplies. The dynamic import keeps mermaid out of module evaluation, so
+ * nothing touches `document` until a diagram actually renders.
  */
 import type { MermaidRenderer } from './mermaid-renderer';
 /**
- * Chained, not concurrent: the site config is process-global, so two renders straddling a
- * theme flip would interleave and one diagram would come back half-themed.
+ * One after another, not together: the config is global to the process, so two renders either
+ * side of a theme change would interleave and one diagram would come back half-themed.
  */
 export declare const mermaidRenderer: MermaidRenderer;

package/dist/plugins/mermaid/renderer.js

@@ -1,7 +1,7 @@
 /**
- * The engine adapter behind the `@voithos-labs/aragonite/plugins/mermaid/renderer` subpath, the
- * consumer half of the injection seam. The dynamic import keeps the engine off module
- * eval, so nothing touches `document` until a diagram actually renders.
+ * The mermaid adapter behind the `@voithos-labs/aragonite/plugins/mermaid/renderer` subpath,
+ * the half a consumer supplies. The dynamic import keeps mermaid out of module evaluation, so
+ * nothing touches `document` until a diagram actually renders.
  */
 /** Respread on every re-initialize, because mermaid's `initialize` replaces the site
  *  config rather than patching it. */
@@ -13,11 +13,8 @@ const BASE_CONFIG = {
     suppressErrorRendering: true
 };
 const MERMAID_THEMES = new Set(['default', 'base', 'dark', 'forest', 'neutral']);
-/**
- * Mermaid's own names pass through, so a consumer can name its editor theme `'forest'` and
- * get it; anything else falls to mermaid's light palette. Wrapping this injected renderer to
- * rewrite `context.theme` is how a custom theme maps.
- */
+/** Mermaid's own theme names pass through (an editor theme named `'forest'` gets it) and anything
+ *  else gets its light palette; wrap the renderer to map a custom theme onto one of mermaid's. */
 function toMermaidTheme(editorTheme) {
     return (MERMAID_THEMES.has(editorTheme) ? editorTheme : 'default');
 }
@@ -41,11 +38,11 @@ async function renderThemed(code, id, theme) {
     return svg;
 }
 /**
- * Chained, not concurrent: the site config is process-global, so two renders straddling a
- * theme flip would interleave and one diagram would come back half-themed.
+ * One after another, not together: the config is global to the process, so two renders either
+ * side of a theme change would interleave and one diagram would come back half-themed.
  */
 export const mermaidRenderer = (code, id, context) => {
-    const theme = toMermaidTheme(context?.theme ?? 'dark');
+    const theme = toMermaidTheme(context.theme);
     const svg = queue.then(() => renderThemed(code, id, theme));
     // The chain must survive a rejection, or one bad diagram strands every later render.
     queue = svg.then(() => { }, () => { });

package/dist/plugins/parrot/ParrotBlock.svelte

@@ -1,6 +1,6 @@
 <!-- ParrotBlock.svelte -->
 <script lang="ts">
-	import { createEditableLeaf, type NodeView } from '../../plugin';
+	import { createEditableLeaf, trimWhitespace, type NodeView } from '../../plugin';
 
 	let { node, index, myPath = [] }: { node: NodeView; index: number; myPath?: number[] } = $props();
 	let sourceEl: HTMLDivElement | undefined = $state();
@@ -220,13 +220,21 @@ Ol;......................................;l'
 cNd.........................................;lOc
 `
 	];
-	// One strip the CSS scrolls a frame at a time. The closing newline is load-bearing: a `pre`
+	// One strip the CSS scrolls a frame at a time. The closing newline matters: a `pre`
 	// drops a trailing blank line, and a strip a row short steps a fraction off every frame.
 	const REEL = FRAMES.join('\n') + '\n';
 	// The clip window's height, which is why every frame has to be the same number of rows.
 	const FRAME_ROWS = FRAMES[0].split('\n').length;
 
-	const caption = $derived(node.raw.slice('%%parrot'.length).trim());
+	// The caption is the rest of the marker line, trimmed, and `start` is where it sits in the
+	// source: `parrotCaretAtPoint` reads it off the element to map a press back to a byte.
+	function parrotCaption(raw: string): { text: string; start: number } {
+		const rest = raw.slice('%%parrot'.length);
+		const text = trimWhitespace(rest);
+		return { text, start: '%%parrot'.length + rest.indexOf(text) };
+	}
+
+	const caption = $derived(parrotCaption(node.raw));
 
 	export const editable = true;
 	export const focusable = true;
@@ -237,8 +245,8 @@ cNd.........................................;lOc
 	export const getSelectedText = leaf.getSelectedText;
 	export const setSelection = leaf.setSelection;
 	export const measurePartialRects = leaf.measurePartialRects;
-	export const runCommand = leaf.runCommand;
 	export const insertMarkdown = leaf.insertMarkdown;
+	export const afterSourceCommit = leaf.afterSourceCommit;
 </script>
 
 <div
@@ -258,11 +266,12 @@ cNd.........................................;lOc
 	{:else}
 		<div
 			class="parrot-caption"
+			data-caption-start={caption.start}
 			role="button"
 			tabindex="-1"
 			aria-label="Party parrot caption (click to edit)"
 		>
-			{caption}
+			{caption.text}
 		</div>
 	{/if}
 </div>
@@ -273,14 +282,16 @@ cNd.........................................;lOc
 		font-size: 1.1em;
 		line-height: 1.1;
 		letter-spacing: 0.05em;
-		/* one frame tall, in the reel's own rows so a step lands on the next frame exactly */
+		/* one frame tall, in the reel's own rows so a step lands on the next frame exactly; the
+		   em line is the same height for engines without lh (Safari before 16.4) */
+		height: calc(var(--parrot-rows) * 1.1em);
 		height: calc(var(--parrot-rows) * 1lh);
 		/* wider than a phone column, and the editor root pans if it isn't contained; the bar
 		   would sit across the bird, which is decoration rather than a pane to scroll */
 		overflow-x: auto;
 		overflow-y: hidden;
 		scrollbar-width: none;
-		/* chrome, not content: every frame is in the DOM and none of them belong in a copy */
+		/* decoration, not content: every frame is in the DOM and none of them belong in a copy */
 		user-select: none;
 		animation: parrot-hue 0.49s step-end infinite;
 	}

package/dist/plugins/parrot/ParrotBlock.svelte.d.ts

@@ -14,8 +14,8 @@ declare const ParrotBlock: import("svelte").Component<$$ComponentProps, {
     getSelectedText: () => string;
     setSelection: (start: number, end: number) => void;
     measurePartialRects: (startOffset: number, endOffset: number) => DOMRect[];
-    runCommand: (id: import("../../plugin").CommandId) => boolean;
-    insertMarkdown: (md: string) => boolean;
+    insertMarkdown: (md: string) => Promise<boolean>;
+    afterSourceCommit: (run: () => void) => void;
 }, "">;
 type ParrotBlock = ReturnType<typeof ParrotBlock>;
 export default ParrotBlock;

package/dist/plugins/parrot/parrot-plugin.js

@@ -2,15 +2,15 @@
 import { caretOffsetAtPoint, declarePluginKind, definePluginBlock, registerBlockKind, registerBlockOpener, simpleLeafClosure } from '../../plugin';
 import ParrotBlock from './ParrotBlock.svelte';
 export const PARROT = 'parrot';
-/** Where a press in the block puts the caret. The caption renders the bytes after `%%parrot `,
- *  so an offset in it sits that far along the source; the revealed source IS the source. */
+/** Where a click in the block puts the caret. The caption says where it starts in the source,
+ *  so an offset in it sits that far along; the shown source is the source itself. */
 function parrotCaretAtPoint(blockEl, clientX, clientY) {
     const source = blockEl.querySelector('.parrot-source');
     const view = source ?? blockEl.querySelector('.parrot-caption');
     if (!view)
         return null;
     const offset = caretOffsetAtPoint(view, clientX, clientY) ?? 0;
-    return { path: [], offset: source ? offset : offset + '%%parrot '.length };
+    return { path: [], offset: source ? offset : offset + Number(view.dataset.captionStart) };
 }
 function registerParrotBlock() {
     const parrot = declarePluginKind(PARROT);

package/dist/plugins/slash-commands/filter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * How a `/` query picks rows: a prefix match on the label or a keyword, and at most one argument
+ * after the first space. Pure, so the list's narrowing is testable without an editor.
+ */
+export interface FilterableEntry {
+    readonly label: string;
+    readonly keywords: readonly string[];
+    readonly takesArgument: boolean;
+}
+export interface SplitQuery {
+    /** The words before the first space: what names the entry. */
+    head: string;
+    /** What follows the first space, or null when the query has none. */
+    argument: string | null;
+}
+export declare function splitQuery(query: string): SplitQuery;
+/** The entries whose label or a keyword starts with `head`, ignoring case, in their given order. */
+export declare function filterEntries<T extends FilterableEntry>(entries: readonly T[], head: string): T[];
+/**
+ * Whether the session outlives this query. A space ends it unless the words before it name
+ * exactly one entry that takes an argument, so `and / or` stays text; the argument is one word.
+ */
+export declare function acceptsQuery(entries: readonly FilterableEntry[], query: string): boolean;

package/dist/plugins/slash-commands/filter.js

@@ -0,0 +1,31 @@
+/**
+ * How a `/` query picks rows: a prefix match on the label or a keyword, and at most one argument
+ * after the first space. Pure, so the list's narrowing is testable without an editor.
+ */
+export function splitQuery(query) {
+    const space = query.search(/\s/);
+    if (space === -1)
+        return { head: query, argument: null };
+    return { head: query.slice(0, space), argument: query.slice(space + 1) };
+}
+/** The entries whose label or a keyword starts with `head`, ignoring case, in their given order. */
+export function filterEntries(entries, head) {
+    const wanted = head.toLowerCase();
+    return entries.filter((entry) => entry.label.toLowerCase().startsWith(wanted) ||
+        entry.keywords.some((keyword) => keyword.toLowerCase().startsWith(wanted)));
+}
+/**
+ * Whether the session outlives this query. A space ends it unless the words before it name
+ * exactly one entry that takes an argument, so `and / or` stays text; the argument is one word.
+ */
+export function acceptsQuery(entries, query) {
+    if (/[\r\n]/.test(query))
+        return false;
+    const { head, argument } = splitQuery(query);
+    if (argument === null)
+        return true;
+    if (/\s/.test(argument))
+        return false;
+    const named = filterEntries(entries, head);
+    return named.length === 1 && named[0].takesArgument;
+}

package/dist/plugins/slash-commands/index.d.ts

@@ -0,0 +1,2 @@
+export { slashCommandsPlugin, SLASH_COMMANDS_OPEN } from './slash-commands-plugin';
+export { SLASH_COMMANDS_MENU, type SlashCommandEntry, type SlashCommandsOptions } from './slash-source';

package/dist/plugins/slash-commands/index.js

@@ -0,0 +1,2 @@
+export { slashCommandsPlugin, SLASH_COMMANDS_OPEN } from './slash-commands-plugin';
+export { SLASH_COMMANDS_MENU } from './slash-source';

package/dist/plugins/slash-commands/slash-commands-plugin.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Slash commands: `/` at the start of a line or after a space lists the blocks to insert, three
+ * heading levels and the host's own rows. Built on public API alone: an inline-menu source, the
+ * insert catalogue, and a global command (`Mod+/`) that types the `/` for a keyboard or touch user.
+ */
+import { type EditorPlugin } from '../../plugin';
+import { type SlashCommandsOptions } from './slash-source';
+/** `runCommand(SLASH_COMMANDS_OPEN, 'table')` opens the list already narrowed to its argument. */
+export declare const SLASH_COMMANDS_OPEN = "slashCommands.open";
+/** `options` are every editor's defaults; an editor's `{ plugin, options }` entry replaces them
+ *  field by field, so passing `exclude` alone keeps these `entries`. */
+export declare function slashCommandsPlugin(options?: SlashCommandsOptions): EditorPlugin;

package/dist/plugins/slash-commands/slash-commands-plugin.js

@@ -0,0 +1,40 @@
+/**
+ * Slash commands: `/` at the start of a line or after a space lists the blocks to insert, three
+ * heading levels and the host's own rows. Built on public API alone: an inline-menu source, the
+ * insert catalogue, and a global command (`Mod+/`) that types the `/` for a keyboard or touch user.
+ */
+import { definePlugin, registerGlobalCommand } from '../../plugin';
+import { createSlashSource, SLASH_COMMANDS_MENU } from './slash-source';
+/** `runCommand(SLASH_COMMANDS_OPEN, 'table')` opens the list already narrowed to its argument. */
+export const SLASH_COMMANDS_OPEN = 'slashCommands.open';
+/** `options` are every editor's defaults; an editor's `{ plugin, options }` entry replaces them
+ *  field by field, so passing `exclude` alone keeps these `entries`. */
+export function slashCommandsPlugin(options = {}) {
+    checkEntries(options.entries);
+    return definePlugin({
+        name: 'slash-commands',
+        defaults: options,
+        parseOptions(raw) {
+            const { entries, exclude } = (raw ?? {});
+            checkEntries(entries);
+            return { entries, exclude };
+        },
+        setup(ctx) {
+            registerGlobalCommand(SLASH_COMMANDS_OPEN, (editor, arg) => editor.inlineMenus.open(SLASH_COMMANDS_MENU, {
+                query: typeof arg === 'string' ? arg : undefined
+            }), { chord: 'Mod+/' });
+            ctx.onEditor((editor) => {
+                const handle = editor.inlineMenus.addSource(createSlashSource(editor));
+                return () => handle.dispose();
+            });
+        }
+    });
+}
+/** A row that neither inserts nor runs would do nothing when picked, so it is refused up front. */
+function checkEntries(entries) {
+    for (const entry of entries ?? []) {
+        if ((entry.insert === undefined) === (entry.run === undefined)) {
+            throw new Error(`slashCommandsPlugin: entry '${entry.id}' needs exactly one of insert and run`);
+        }
+    }
+}

package/dist/plugins/slash-commands/slash-source.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The `/` list: the insert catalogue, three heading rows and the host's own entries, read fresh
+ * from the editor on every keystroke. A pick removes the `/query` bytes first (its `insert` is
+ * empty), then `onCommit` does the row's work through the editor's own entry points.
+ */
+import { type EditorContext, type InlineMenuSource, type MenuIconName } from '../../plugin';
+export declare const SLASH_COMMANDS_MENU = "slash-commands";
+interface SlashCommandEntryBase {
+    /** Unique among host rows; a built-in id here replaces that built-in row. */
+    id: string;
+    label: string;
+    icon?: MenuIconName;
+    /** Other words the query finds the row by. */
+    keywords?: readonly string[];
+}
+/** A host's own row: Markdown to insert, or a function to run. Never both, never neither. */
+export type SlashCommandEntry = SlashCommandEntryBase & ({
+    insert: string;
+    run?: never;
+    takesArgument?: never;
+} | {
+    /** Runs after the `/query` bytes are gone, with the argument typed after a space. */
+    run: (editor: EditorContext, argument?: string) => void;
+    /** Lets the list survive a space, so `/name word` hands `word` to `run`. */
+    takesArgument?: boolean;
+    insert?: never;
+});
+export interface SlashCommandsOptions {
+    /** Rows added after the built-in ones. */
+    entries?: readonly SlashCommandEntry[];
+    /** Built-in row ids to leave out: an insert catalogue id, or `h1`, `h2`, `h3`. */
+    exclude?: readonly string[];
+}
+/** The `/` source for one editor: its rows come from `editor.options` and the live catalogue. */
+export declare function createSlashSource(editor: EditorContext<SlashCommandsOptions>): InlineMenuSource;
+export {};