@suzumiyaaoba/mdxr 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,2902 @@
+#!/usr/bin/env node
+import { F as shadcnModules, Fl as parseDiff, Fu as fenceFilename, Gu as own, Hu as isComponent, Iu as fenceLang, Ku as urlScheme, Lu as parseLineRange, Nl as langForPath, Pu as takeUsedIcons, Ru as splitPathLines, Uu as isRecord, Wu as nonEmpty, cu as isStatus, gc as PlanHeader, jl as SKIP_LANGS, ou as STATUSES, t as builtinComponents, zu as DocContext } from "./ui-GKFD0mx5.mjs";
+import { a as loadUserModule, c as srcDir, i as importBundledCode, n as loadConfig, o as resolveModuleEntry, r as SHARED_PACKAGES, s as pkgRoot } from "./config-SI9IyFiC.mjs";
+import module from "node:module";
+import fsp, { access, readFile, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { cac } from "cac";
+import * as valibot from "valibot";
+import { Fragment, createElement } from "react";
+import { icons } from "@iconify-json/lucide";
+import { icons as icons$1 } from "@iconify-json/vscode-icons";
+import fs, { existsSync, readFileSync } from "node:fs";
+import { build } from "esbuild";
+import os from "node:os";
+import { compile } from "@mdx-js/mdx";
+import { renderToStaticMarkup, renderToString } from "react-dom/server";
+import rehypeKatex from "rehype-katex";
+import remarkDirective from "remark-directive";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import { VFile } from "vfile";
+import { matter } from "vfile-matter";
+import { transformerMetaHighlight, transformerMetaWordHighlight, transformerNotationDiff, transformerNotationErrorLevel, transformerNotationFocus, transformerNotationHighlight, transformerNotationWordHighlight, transformerRemoveNotationEscape } from "@shikijs/transformers";
+import { createHighlighter } from "shiki";
+import { visit } from "unist-util-visit";
+import { visitParents } from "unist-util-visit-parents";
+import { compile as compile$1, optimize } from "@tailwindcss/node";
+import { Scanner } from "@tailwindcss/oxide";
+import { once } from "node:events";
+import http from "node:http";
+//#region src/catalog.ts
+/** Structural view of a valibot schema — enough for catalog introspection. */
+const describeSchema = (schema) => {
+	if (!isRecord(schema)) return "unknown";
+	if (schema.type === "array") return `${describeSchema(schema.item)}[]`;
+	if (schema.type === "literal") return JSON.stringify(schema.literal);
+	if (schema.type === "picklist" && Array.isArray(schema.options)) return schema.options.map((o) => JSON.stringify(o)).join(" | ");
+	if (schema.type === "union" && Array.isArray(schema.options)) return schema.options.map(describeSchema).join(" | ");
+	if (Array.isArray(schema.pipe)) {
+		const constrained = schema.pipe.find((s) => isRecord(s) && (s.type === "picklist" || s.type === "union" || s.type === "literal"));
+		if (constrained !== void 0) return describeSchema(constrained);
+	}
+	return typeof schema.type === "string" ? schema.type : "unknown";
+};
+const WRAPPER_TYPES = /* @__PURE__ */ new Set([
+	"nullable",
+	"nullish",
+	"optional"
+]);
+const unwrapProp = (raw) => {
+	let s = isRecord(raw) ? raw : {};
+	let required = true;
+	let def;
+	while (typeof s.type === "string" && WRAPPER_TYPES.has(s.type)) {
+		required = false;
+		def ??= s.default;
+		s = isRecord(s.wrapped) ? s.wrapped : {};
+	}
+	return {
+		def,
+		required,
+		s
+	};
+};
+const propsOf = (schema) => {
+	if (!isRecord(schema) || !isRecord(schema.entries)) return {};
+	const out = {};
+	for (const [key, raw] of Object.entries(schema.entries)) {
+		const { def, required, s } = unwrapProp(raw);
+		Object.defineProperty(out, key, {
+			configurable: true,
+			enumerable: true,
+			value: {
+				required,
+				type: describeSchema(s),
+				...def === void 0 ? {} : { default: def }
+			},
+			writable: true
+		});
+	}
+	return out;
+};
+const entryOf = (name, comp, source) => ({
+	description: comp.__mdxr?.description,
+	name,
+	props: propsOf(comp.__mdxr?.schema),
+	source
+});
+const catalogEntries = (project = {}) => {
+	const entries = [];
+	for (const [name, comp] of Object.entries(builtinComponents)) {
+		if (!/^[A-Z]/u.test(name)) continue;
+		const overridden = Object.hasOwn(project, name);
+		const shown = overridden ? project[name] ?? comp : comp;
+		entries.push(entryOf(name, shown, overridden ? "project" : "builtin"));
+	}
+	for (const [name, comp] of Object.entries(project)) if (!Object.hasOwn(builtinComponents, name)) entries.push(entryOf(name, comp, "project"));
+	return entries;
+};
+/** Conventions the agent can use without JSX (kept in sync with remark plugins). */
+const CONVENTIONS = [
+	{
+		result: "Callout (with kind)",
+		syntax: ":::note | :::tip | :::warning | :::danger | :::decision | :::goal | :::nongoal | :::question | :::answer"
+	},
+	{
+		result: "Phase",
+		syntax: ":::phase{title=\"...\" status=\"doing\"}"
+	},
+	{
+		result: "Steps container",
+		syntax: ":::steps"
+	},
+	{
+		result: "Flow (numbered call/execution chain)",
+		syntax: ":::flow{title=\"...\"}"
+	},
+	{
+		result: "Findings container / Finding block",
+		syntax: ":::findings · :::finding{confidence=\"inferred\" title=\"...\"}"
+	},
+	{
+		result: "Files container (related files)",
+		syntax: ":::files"
+	},
+	{
+		result: "Deps container (dependency edges)",
+		syntax: ":::deps"
+	},
+	{
+		result: "Tests container (test report)",
+		syntax: ":::tests"
+	},
+	{
+		result: "Endpoints container (API routes)",
+		syntax: ":::endpoints"
+	},
+	{
+		result: "Board container (kanban)",
+		syntax: ":::board"
+	},
+	{
+		result: "Graph container (static node/edge SVG, dagre layout)",
+		syntax: ":::graph{title=\"...\" direction=\"right\"}"
+	},
+	{
+		result: "Waterfall container (timing bars)",
+		syntax: ":::waterfall"
+	},
+	{
+		result: "Gantt container (date-based schedule)",
+		syntax: ":::gantt{title=\"...\"}"
+	},
+	{
+		result: "Matrix container (comparison grid)",
+		syntax: ":::matrix"
+	},
+	{
+		result: "Timeline",
+		syntax: ":::timeline{title=\"...\"}"
+	},
+	{
+		result: "Review container (code review report)",
+		syntax: ":::review{title=\"...\" verdict=\"changes\"}"
+	},
+	{
+		result: "Checks container (CI/verification status)",
+		syntax: ":::checks"
+	},
+	{
+		result: "Audit container (vulnerability inventory)",
+		syntax: ":::audit{tool=\"npm audit\"}"
+	},
+	{
+		result: "Bumps container (dependency upgrades)",
+		syntax: ":::bumps"
+	},
+	{
+		result: "Packages container (dependency inventory)",
+		syntax: ":::packages"
+	},
+	{
+		result: "Gauges container (percent-bar rows: coverage, scores)",
+		syntax: ":::gauges"
+	},
+	{
+		result: "Benchmarks container (before/after comparisons)",
+		syntax: ":::benchmarks{better=\"lower\"}"
+	},
+	{
+		result: "Schema container (DB table definitions)",
+		syntax: ":::schema"
+	},
+	{
+		result: "EnvVars container (environment variable docs)",
+		syntax: ":::envvars"
+	},
+	{
+		result: "StatusPage container (service health rollup)",
+		syntax: ":::statuspage"
+	},
+	{
+		result: "Uptime container (status-page day bars)",
+		syntax: ":::uptime{pct=\"99.9\"}"
+	},
+	{
+		result: "Release container (changelog block)",
+		syntax: ":::release{version=\"v1.0.0\"}"
+	},
+	{
+		result: "Pathway container (version/env stepper)",
+		syntax: ":::pathway{title=\"...\"}"
+	},
+	{
+		result: "Incident header (postmortem card)",
+		syntax: ":::incident{title=\"...\" severity=\"high\"}"
+	},
+	{
+		result: "Verdict banner (approve/pass/warn/fail conclusion)",
+		syntax: ":::verdict{status=\"approve\"}"
+	},
+	{
+		result: "chart containers (quantitative visualizations)",
+		syntax: ":::barchart · :::linechart · :::piechart · :::scatter · :::radar · :::funnel · :::quadrant · :::bridge · :::treemap · :::sankey · :::venn"
+	},
+	{
+		result: "table of contents (auto from headings)",
+		syntax: ":::toc"
+	},
+	{
+		result: "Callout (GitHub alert)",
+		syntax: "> [!NOTE] / [!WARNING] / ..."
+	},
+	{
+		result: "diagram (mermaid via CDN)",
+		syntax: "```mermaid fenced block"
+	},
+	{
+		result: "unified-diff cards (per-file headers, hunk line numbers)",
+		syntax: "```diff or ```patch fenced block"
+	},
+	{
+		result: "math (KaTeX via CDN)",
+		syntax: "$…$ inline / $$…$$ block"
+	},
+	{
+		result: "code block (syntax-highlighted) with filename header",
+		syntax: "```lang title=\"file.ts\""
+	},
+	{
+		result: "FileRef chip (editor link when the file exists)",
+		syntax: "`src/x.ts` inline code naming a real file"
+	},
+	{
+		result: "code line highlights / line numbers",
+		syntax: "```ts {1,3-5} · ```ts ln · /word/ in meta"
+	},
+	{
+		result: "in-code markers (stripped from output)",
+		syntax: "// [!code hl] · [!code ++] · [!code --] · [!code warning] · [!code error] · [!code focus] · [!code word:x]"
+	},
+	{
+		result: "embed a real file as a code block",
+		syntax: "<CodeFile path=\"src/x.ts\" lines=\"40-52\" />"
+	},
+	{
+		result: "styled markdown",
+		syntax: "GFM tables, task lists, strikethrough, footnotes"
+	},
+	{
+		result: "Iconify icon (inline SVG, lucide + vscode-icons bundled)",
+		syntax: "<Icon name=\"lucide:rocket\"> or class=\"icon-[lucide--rocket]\""
+	}
+];
+const formatCatalog = (entries) => {
+	const lines = ["Components:", ""];
+	for (const e of entries) {
+		const props = Object.entries(e.props).map(([k, p]) => `${k}${p.required ? "" : "?"}: ${p.type}`).join(", ");
+		lines.push(`  <${e.name}${props === "" ? "" : ` ${props}`}>`);
+		if (e.description !== void 0) lines.push(`      ${e.description}`);
+		if (e.source === "project") lines.push("      (project-defined)");
+		lines.push("");
+	}
+	lines.push("Conventions:");
+	for (const c of CONVENTIONS) lines.push(`  ${c.syntax}  →  ${c.result}`);
+	return lines.join("\n");
+};
+//#endregion
+//#region src/format-error.ts
+/**
+* Validate the `--format` flag: omitted and "text" mean human-readable
+* errors, "json" switches failure output to a machine-readable object.
+*/
+const parseErrorFormat = (format) => {
+	if (format === void 0 || format === "text") return "text";
+	if (format === "json") return "json";
+	throw new Error(`invalid --format "${format}" (expected text|json)`);
+};
+const formatError = (err) => {
+	if (err instanceof Error) {
+		const e = err;
+		const loc = e.line === null || e.line === void 0 ? "" : `:${e.line}:${e.column ?? 0}`;
+		return `${e.file ?? ""}${loc} ${e.message}`.trim();
+	}
+	return String(err);
+};
+const levenshtein = (a, b) => {
+	const dp = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array.from({ length: b.length }, () => 0)]);
+	for (let j = 1; j <= b.length; j += 1) dp[0][j] = j;
+	for (let i = 1; i <= a.length; i += 1) for (let j = 1; j <= b.length; j += 1) dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+	return dp[a.length][b.length];
+};
+/**
+* MDX's "Expected component `<X>`" errors get a friendlier message: the
+* closest catalog name (edit distance ≤ 3) plus the full list, so the agent
+* can self-correct without a `mdxr catalog` round-trip.
+*/
+const enhanceRenderError = (err, componentNames) => {
+	if (!(err instanceof Error)) return err;
+	const name = /Expected component [`"'](?<name>\w+)[`"']/u.exec(err.message)?.groups?.name;
+	if (name === void 0) return err;
+	const names = componentNames.filter((n) => /^[A-Z]/u.test(n));
+	const [nearest] = names.map((n) => ({
+		d: levenshtein(name.toLowerCase(), n.toLowerCase()),
+		n
+	})).toSorted((x, y) => x.d - y.d);
+	const hint = nearest !== void 0 && nearest.d <= 3 ? ` Did you mean <${nearest.n}>?` : "";
+	return new Error(`Unknown component <${name}>.${hint} Available: ${names.join(", ")}. Add custom components via mdxr.config.ts.`, { cause: err });
+};
+//#endregion
+//#region src/init.ts
+const SKILL_DIRS = {
+	agents: {
+		global: ".agents/skills/mdxr",
+		local: ".agents/skills/mdxr"
+	},
+	claude: {
+		global: ".claude/skills/mdxr",
+		local: ".claude/skills/mdxr"
+	},
+	devin: {
+		global: ".config/devin/skills/mdxr",
+		local: ".devin/skills/mdxr"
+	}
+};
+const installSkill = async (opts) => {
+	const tool = opts.tool ?? "agents";
+	const global = opts.global === true;
+	const base = global ? os.homedir() : process.cwd();
+	const dests = (tool === "all" ? Object.keys(SKILL_DIRS) : [tool]).map((t) => {
+		const dirs = own(SKILL_DIRS, t);
+		if (dirs === void 0) throw new Error(`unknown tool: ${t} (expected agents|claude|devin|all)`);
+		return path.join(base, global ? dirs.global : dirs.local);
+	});
+	for (const dest of dests) if (fs.existsSync(dest) && opts.force !== true) throw new Error(`${dest} already exists (use --force to overwrite)`);
+	return await Promise.all(dests.map(async (dest) => {
+		await fsp.mkdir(path.dirname(dest), { recursive: true });
+		if (opts.force === true) await fsp.rm(dest, {
+			force: true,
+			recursive: true
+		});
+		await fsp.cp(path.join(pkgRoot, "skill"), dest, {
+			force: true,
+			recursive: true
+		});
+		return dest;
+	}));
+};
+//#endregion
+//#region src/client-js.ts
+let cache;
+const buildClientJs = async () => {
+	return (await build({
+		absWorkingDir: pkgRoot,
+		bundle: true,
+		format: "iife",
+		logLevel: "silent",
+		minify: true,
+		platform: "browser",
+		stdin: {
+			contents: "import \"./client/entry.js\";",
+			loader: "js",
+			resolveDir: path.join(pkgRoot, "src"),
+			sourcefile: "mdxr-client.js"
+		},
+		target: "es2022",
+		write: false
+	})).outputFiles[0]?.text ?? "";
+};
+/**
+* Vanilla JS inlined into every document (copy/answer/save buttons, the
+* live Markdown answer sheet, the theme toggle). Bundled from
+* `src/client/entry.ts` at render time — real source, so the script is
+* type-checked and unit-testable, and bundler changes can't silently
+* break it the way `fn.toString()` serialization could. Memoized: the
+* bundle is identical for every render in a process.
+*/
+const clientJs = async () => {
+	cache ??= buildClientJs();
+	try {
+		return await cache;
+	} catch (error) {
+		cache = void 0;
+		throw error;
+	}
+};
+//#endregion
+//#region src/component-map.ts
+/**
+* `into[k] = v` with `k === "__proto__"` would silently replace the map's
+* prototype instead of registering the component — define it as data.
+*/
+const put = (into, k, v) => {
+	Object.defineProperty(into, k, {
+		configurable: true,
+		enumerable: true,
+		value: v,
+		writable: true
+	});
+};
+/** A default-exported object is treated as a `{ Name: Component }` map. */
+const mergeDefaultMap = (val, into) => {
+	if (!isRecord(val)) return;
+	for (const [k, v] of Object.entries(val)) if (isComponent(v)) put(into, k, v);
+};
+/**
+* Merge a user module's exports into a ComponentMap. A default-exported
+* object is treated as a `{ Name: Component }` map; PascalCase named exports
+* that are functions count directly. Shared by the SSR loader (render.ts)
+* and the hydration bundle (hydrate-runtime.ts) — node-free on purpose.
+*/
+const mergeUserComponents = (mod, into = {}) => {
+	for (const [key, val] of Object.entries(mod)) if (key === "default") mergeDefaultMap(val, into);
+	else if (isComponent(val) && /^[A-Z]/u.test(key)) put(into, key, val);
+	return into;
+};
+/** Mermaid bootstrap (module). Only injected when the document uses it. */
+const MERMAID_JS = `
+import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs';
+mermaid.initialize({
+  startOnLoad: false,
+  theme: matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'default',
+});
+await mermaid.run({ nodes: document.querySelectorAll('.mermaid') });
+`;
+/**
+* KaTeX stylesheet (fonts resolve relative to this URL on the CDN). Only
+* linked when the document contains math — same CDN-on-demand model as
+* mermaid. Version matches the bundled `katex` dependency.
+*/
+const KATEX_CDN_URL = "https://cdn.jsdelivr.net/npm/katex@0.18.7/dist/katex.min.css";
+/** Live-reload snippet injected by `mdxr serve` only. */
+const LIVE_RELOAD_JS = `
+var es = new EventSource('/__mdxr_events');
+es.addEventListener('reload', function () { location.reload(); });
+`;
+/**
+* The shadcn theme maps `dark:` to the `.dark` class, so dark mode is
+* class-based rather than media-based. This head script applies the class
+* before first paint: a stored choice from the theme toggle
+* (localStorage `mdxr-theme`) wins, otherwise the document tracks
+* `prefers-color-scheme` — and keeps tracking it only while no explicit
+* choice is stored.
+*/
+const THEME_JS = `
+var q = matchMedia('(prefers-color-scheme: dark)');
+var stored = null;
+try { stored = localStorage.getItem('mdxr-theme'); } catch (e) {}
+document.documentElement.classList.toggle(
+  'dark',
+  stored === 'dark' || (stored !== 'light' && q.matches)
+);
+q.addEventListener('change', function (e) {
+  var s = null;
+  try { s = localStorage.getItem('mdxr-theme'); } catch (e2) {}
+  if (s !== 'light' && s !== 'dark') {
+    document.documentElement.classList.toggle('dark', e.matches);
+  }
+});
+// This script runs in <head>, before the toggle button is parsed —
+// reflect the stored mode on it once the DOM exists.
+addEventListener('DOMContentLoaded', function () {
+  var s = null;
+  try { s = localStorage.getItem('mdxr-theme'); } catch (e) {}
+  var mode = s === 'light' || s === 'dark' ? s : 'auto';
+  document.querySelectorAll('[data-mdxr-theme]').forEach(function (b) {
+    if (!(b instanceof HTMLElement)) {
+      return;
+    }
+    b.dataset.mode = mode;
+    b.setAttribute('title', 'Theme: ' + mode);
+    b.setAttribute('aria-label', 'Switch theme (current: ' + mode + ')');
+  });
+});
+`;
+//#endregion
+//#region src/html.ts
+/**
+* JS destined for an inline `<script>` element: neutralize the two byte
+* sequences the HTML parser treats specially (`<\/script` ends the element,
+* `<!--` opens a comment escape). `\u003C` keeps the meaning in strings,
+* comments, and regex literals alike. Applied centrally here so every
+* snippet — authored constants, the client bundle, the hydrate bundle —
+* is safe regardless of its producer.
+*/
+const inlineScript = (js) => js.replaceAll(/<\/script/giu, "\\u003C/script").replaceAll("<!--", "\\u003C!--");
+/**
+* Inline `<style>` content: a `</style` byte sequence inside the CSS (e.g. a
+* `content:` string in user theme CSS) would end the element early. `<\/`
+* reads identically inside CSS strings/comments, so it's safe to emit.
+*/
+const inlineStyle = (css) => css.replaceAll(/<\/style/giu, "<\\/style");
+const ESCAPES = {
+	"\"": "&quot;",
+	"&": "&amp;",
+	"'": "&#39;",
+	"<": "&lt;",
+	">": "&gt;"
+};
+const escapeHtml = (s) => s.replaceAll(/[&<>"']/gu, (c) => ESCAPES[c] ?? c);
+/** Inline SVG from the bundled lucide set (bodies carry stroke attrs). */
+const iconSvg = (name) => {
+	const icon = icons.icons[name];
+	return `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 ${icon?.width ?? 24} ${icon?.height ?? 24}" class="lucide" aria-hidden="true">${icon?.body ?? ""}</svg>`;
+};
+/**
+* Theme toggle button — document chrome fixed to the top-right corner.
+* `data-mode` selects the visible icon (auto → light → dark, cycled by
+* `handleDocEvent`); THEME_JS restores the stored choice before paint.
+*/
+const THEME_TOGGLE_HTML = `<button type="button" class="mdxr-theme" data-mdxr-theme data-mode="auto" title="Theme: auto" aria-label="Switch theme (current: auto)"><span class="mdxr-theme-i mdxr-theme-i-auto">${iconSvg("sun-moon")}</span><span class="mdxr-theme-i mdxr-theme-i-light">${iconSvg("sun")}</span><span class="mdxr-theme-i mdxr-theme-i-dark">${iconSvg("moon")}</span></button>`;
+const htmlDocument = (o) => `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="generator" content="mdxr">
+<title>${escapeHtml(o.title)}</title>
+<script>${inlineScript(THEME_JS)}<\/script>
+${o.needsKatex === true ? `<link rel="stylesheet" href="${KATEX_CDN_URL}">` : ""}
+<style>${inlineStyle(o.css)}</style>
+</head>
+<body class="bg-white text-neutral-900 antialiased dark:bg-neutral-950 dark:text-neutral-100">
+${THEME_TOGGLE_HTML}
+<main id="mdxr-root" class="prose prose-neutral dark:prose-invert mx-auto max-w-3xl px-6 py-10">${o.body}</main>
+<script>${inlineScript(o.clientJs)}<\/script>
+${o.needsMermaid ? `<script type="module">${inlineScript(MERMAID_JS)}<\/script>` : ""}
+${o.liveReload === true ? `<script>${inlineScript(LIVE_RELOAD_JS)}<\/script>` : ""}
+${o.hydrateJs === void 0 ? "" : `<script>${inlineScript(o.hydrateJs)}<\/script>`}
+</body>
+</html>
+`;
+//#endregion
+//#region src/hydrate/export-index.ts
+/**
+* Export-surface scanning for the hydration bundle: which leaf module
+* provides each public name, and which names each public specifier
+* (`@suzumiyaaoba/mdxr`, `…/components`) actually exports. Derived by
+* scanning the
+* leaf modules under `src/ui/` + `src/components/ui/` rather than parsing
+* barrels: any export form (`export *`, `export const`, `export {X}` lists,
+* re-export chains like ask→ask-question) resolves correctly, and new leaf
+* files self-register.
+*/
+let exportIndexCache;
+const DECLARE_RE = /export\s+(?:const|function|class)\s+(?<name>\w+)/gu;
+const REEXPORT_RE = /export\s+(?!type\b)\{(?<names>[^}]*)\}\s*from\s*"(?<mod>\.[^"]+)"/gu;
+/** `export * as name from "x"` — the exported name is `name`. */
+const STAR_AS_RE = /export\s+\*\s+as\s+(?<name>\w+)\s+from\s*"[^"]+"/gu;
+/** `export * from "./x.js"` — the surface walk follows relative targets. */
+const STAR_RE = /export\s+\*\s+from\s*"(?<mod>\.[^"]+)"/gu;
+/** `export { A, B as C }` with no `from` — local re-export list (shadcn style). */
+const LOCAL_EXPORT_RE = /export\s+(?!type\b)\{(?<names>[^}]*)\}(?!\s*from\b)/gu;
+/**
+* `{ A, type B, C as D }` clause → runtime names importers see (`A`, `D`).
+* `type`-marked parts are erased at runtime — emitting `export { B } from "m"`
+* for one would explode the whole bundle with "no matching export".
+*/
+const exportedNames = (names) => (names ?? "").split(",").map((part) => part.trim()).filter((part) => part !== "" && !part.startsWith("type ")).map((part) => part.split(/\s+as\s+/u).pop()?.trim() ?? "").filter((name) => name !== "");
+/** `[exportName, target]` pairs a leaf module re-exports (`export {X as Y} from "./z"`). */
+const reexportTargets = (source, dir) => {
+	const pairs = [];
+	for (const m of source.matchAll(REEXPORT_RE)) {
+		const mod = path.join(dir, m.groups?.mod ?? "");
+		for (const name of exportedNames(m.groups?.names)) pairs.push([name, mod]);
+	}
+	return pairs;
+};
+/** A `./x.js` specifier in our sources maps to `./x.ts`/`.tsx` on disk. */
+const sourceFile = (spec, dir) => {
+	const stem = path.resolve(dir, spec).replace(/\.js$/u, "");
+	for (const ext of [
+		".ts",
+		".tsx",
+		".js"
+	]) {
+		const p = `${stem}${ext}`;
+		if (existsSync(p)) return p;
+	}
+};
+/** Every runtime-exported name in `source` lands in `out`. */
+const collectNames = (source, out) => {
+	for (const m of source.matchAll(DECLARE_RE)) {
+		const name = m.groups?.name;
+		if (name !== void 0) out.add(name);
+	}
+	for (const m of source.matchAll(STAR_AS_RE)) {
+		const name = m.groups?.name;
+		if (name !== void 0) out.add(name);
+	}
+	for (const re of [REEXPORT_RE, LOCAL_EXPORT_RE]) for (const m of source.matchAll(re)) for (const name of exportedNames(m.groups?.names)) out.add(name);
+};
+/**
+* Every name `entry` re-exports, chasing `export *` targets — the surface the
+* real package shows importers. Type-only exports never match the regexes
+* (`export type`, `type X` parts), so the set holds runtime names only.
+*/
+const collectSurface = async (entry) => {
+	const out = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	const walk = async (file) => {
+		if (seen.has(file)) return;
+		seen.add(file);
+		let source;
+		try {
+			source = await readFile(file, "utf-8");
+		} catch {
+			return;
+		}
+		collectNames(source, out);
+		const dir = path.dirname(file);
+		const starTargets = [];
+		for (const m of source.matchAll(STAR_RE)) {
+			const mod = m.groups?.mod;
+			if (mod === void 0) continue;
+			const target = sourceFile(mod, dir);
+			if (target !== void 0) starTargets.push(target);
+		}
+		await Promise.all(starTargets.map(walk));
+	};
+	await walk(entry);
+	return out;
+};
+/**
+* All `name → module` pairs a leaf file claims — declarations plus every
+* re-export form. Returned rather than written into a shared map: callers
+* merge in sorted filename order, so a duplicated export name resolves
+* deterministically instead of racing whichever `readFile` finished last.
+*/
+const scanLeaf = async (filePath) => {
+	const source = await readFile(filePath, "utf-8");
+	const dir = path.dirname(filePath);
+	const pairs = [];
+	for (const m of source.matchAll(DECLARE_RE)) {
+		const name = m.groups?.name;
+		if (name !== void 0) pairs.push([name, filePath]);
+	}
+	for (const [name, mod] of reexportTargets(source, dir)) pairs.push([name, mod]);
+	for (const m of source.matchAll(LOCAL_EXPORT_RE)) for (const name of exportedNames(m.groups?.names)) pairs.push([name, filePath]);
+	for (const m of source.matchAll(STAR_AS_RE)) {
+		const name = m.groups?.name;
+		if (name !== void 0) pairs.push([name, filePath]);
+	}
+	return pairs;
+};
+/**
+* export name → module specifier for every name the catalog can produce,
+* plus the real export surface of each public specifier.
+*/
+const exportIndex = async () => {
+	if (exportIndexCache !== void 0) return exportIndexCache;
+	const map = /* @__PURE__ */ new Map([["DocContext", path.join(srcDir, "doc-context.js")]]);
+	const leafDirs = [path.join(srcDir, "ui"), path.join(srcDir, "components/ui")];
+	const scanned = await Promise.all(leafDirs.map(async (dir) => {
+		const files = (await readdir(dir)).filter((f) => /\.tsx?$/u.test(f) && f !== "index.ts").toSorted();
+		return await Promise.all(files.map(async (f) => await scanLeaf(path.join(dir, f))));
+	}));
+	for (const pairs of scanned.flat()) for (const [name, mod] of pairs) map.set(name, mod);
+	for (const [name, mod] of Object.entries(shadcnModules)) map.set(name, path.join(srcDir, "ui", mod));
+	const index = {
+		map,
+		surfaces: {
+			components: await collectSurface(path.join(srcDir, "components.ts")),
+			mdxr: await collectSurface(path.join(srcDir, "index.ts"))
+		}
+	};
+	exportIndexCache = index;
+	return index;
+};
+//#endregion
+//#region src/hydrate/plugins.ts
+/**
+* esbuild plugins for the hydration bundle: pin shared packages to mdxr's own
+* node_modules (a second React copy would break hooks/context), feed the
+* compiled MDX module in as a virtual import, and shrink bundled icon sets to
+* the names a document actually rendered.
+*/
+/**
+* Everything the document bundle shares with mdxr itself — React above all
+* (a second copy would break hooks/context) — is resolved from this package's
+* own node_modules regardless of where the user's components live.
+* (esbuild serializes onResolve filters to Go's RE2: no `u` flag.)
+*/
+const SHARED_RE = new RegExp(`^(?:${SHARED_PACKAGES.join("|")})(?:/.*)?$`);
+const pinShared = {
+	name: "mdxr:pin-shared",
+	setup(b) {
+		b.onResolve({ filter: SHARED_RE }, async (args) => {
+			if (args.pluginData === pinShared) return null;
+			const r = await b.resolve(args.path, {
+				kind: args.kind,
+				pluginData: pinShared,
+				resolveDir: pkgRoot
+			});
+			return r.errors.length === 0 ? { path: r.path } : null;
+		});
+	}
+};
+/** The compiled MDX module enters the bundle as a virtual `mdxr:doc` import. */
+const docModule = (code) => ({
+	name: "mdxr:doc",
+	setup(b) {
+		b.onResolve({ filter: /^mdxr:doc$/ }, () => ({
+			namespace: "mdxr-doc",
+			path: "mdxr:doc"
+		}));
+		b.onLoad({
+			filter: /^mdxr:doc$/,
+			namespace: "mdxr-doc"
+		}, () => ({
+			contents: code,
+			loader: "js",
+			resolveDir: srcDir
+		}));
+	}
+});
+const ICON_SETS = {
+	"@iconify-json/lucide": icons,
+	"@iconify-json/vscode-icons": icons$1
+};
+/**
+* The bundled icon sets are several MB of JSON; a document only ever renders
+* the icons recorded during SSR. Redirecting each `@iconify-json/*` import to
+* a partial collection (used names only, alias parents included) keeps
+* `addCollection` calls working while shipping kilobytes, not megabytes.
+*/
+const iconSets = (usedIcons) => ({
+	name: "mdxr:icons",
+	setup(b) {
+		b.onResolve({ filter: /^@iconify-json\// }, (args) => ({
+			namespace: "mdxr-icons",
+			path: args.path
+		}));
+		b.onLoad({
+			filter: /^@iconify-json\//,
+			namespace: "mdxr-icons"
+		}, (args) => {
+			const set = ICON_SETS[args.path];
+			if (set === void 0) return {
+				contents: "export const icons = {};",
+				loader: "js"
+			};
+			const icons = {};
+			const aliases = {};
+			for (const full of usedIcons) {
+				const [prefix, name] = full.split(":");
+				if (prefix !== set.prefix || name === void 0) continue;
+				if (Object.hasOwn(set.icons, name)) icons[name] = set.icons[name];
+				const alias = Object.hasOwn(set.aliases ?? {}, name) ? set.aliases?.[name] : void 0;
+				if (alias !== void 0) {
+					aliases[name] = alias;
+					if (Object.hasOwn(set.icons, alias.parent)) icons[alias.parent] = set.icons[alias.parent];
+				}
+			}
+			return {
+				contents: `export const icons = ${JSON.stringify({
+					...set,
+					aliases,
+					icons
+				})};`,
+				loader: "js"
+			};
+		});
+	}
+});
+//#endregion
+//#region src/hydrate/import-scan.ts
+/**
+* User-module import scanning: which names an importer pulls from
+* `@suzumiyaaoba/mdxr`(/components), and which valibot properties it accesses
+* through
+* an imported `v` alias. The virtual runtime module generated for each
+* importer contains only what it requests — a full-surface module would
+* drag the whole catalog into every hydration bundle.
+*/
+/**
+* Properties accessed on `alias` (`v`'s local name) — or `"all"` when the
+* namespace escapes (bare use, `alias[key]`, spread, re-export) and the full
+* valibot namespace must be shipped.
+*/
+const scanVProps = (stripped, alias) => {
+	const esc = alias.replaceAll(/[$()*+.?[\\\]^{|}]/gu, "\\$&");
+	const access = new RegExp(`\\b${esc}\\s*\\?\\.\\s*(\\w+)|\\b${esc}\\s*\\.\\s*(\\w+)`, "gu");
+	const props = /* @__PURE__ */ new Set();
+	for (const use of stripped.matchAll(access)) {
+		const prop = use[1] ?? use[2];
+		if (prop !== void 0) props.add(prop);
+	}
+	const leftover = stripped.replaceAll(access, "");
+	return new RegExp(`\\b${esc}\\b`, "u").test(leftover) ? "all" : props;
+};
+/**
+* `/* … *\/` and `// …` are legal inside a multiline import clause, and a
+* name polluted with comment text would silently fail the surface check and
+* kill the hydration build. Clauses never contain string literals, so a
+* regex strip is safe here.
+*/
+const stripComments = (s) => s.replaceAll(/\/\*[\s\S]*?\*\//gu, "").replaceAll(/\/\/[^\n]*/gu, "");
+/** Parse `{ a, b as c, type T }` import specifiers into names + `v` aliases. */
+const parseClause = (clause, names, vAliases) => {
+	const inner = stripComments(clause);
+	const close = inner.lastIndexOf("}");
+	const body = close === -1 ? inner.slice(1) : inner.slice(1, close);
+	for (const part of body.split(",")) {
+		const [imported, local] = part.trim().replace(/^type\s+/u, "").split(/\s+as\s+/u).map((s) => s?.trim());
+		if (imported === void 0 || imported === "") continue;
+		names.add(imported);
+		if (imported === "v") vAliases.push(local ?? "v");
+	}
+};
+/** Merge per-alias prop scans — `"all"` once any alias escapes. */
+const mergeVProps = (stripped, vAliases, escapes) => {
+	if (escapes) return "all";
+	let vProps = null;
+	for (const alias of vAliases) {
+		const props = scanVProps(stripped, alias);
+		if (props === "all") return "all";
+		vProps = vProps === null ? props : /* @__PURE__ */ new Set([...vProps, ...props]);
+	}
+	return vProps;
+};
+/**
+* Which names `importer` pulls from `@suzumiyaaoba/mdxr`(/components),
+* extracted with a
+* regex over its source. `names`/`vProps` are `"all"` for namespace, default,
+* bare, or dynamic imports and for uninspectable importers — the fallback
+* keeps semantics correct at the cost of emitting every catalog re-export.
+*/
+const scanMdxrImports = async (importer) => {
+	let source;
+	try {
+		source = await readFile(importer, "utf-8");
+	} catch {
+		return {
+			names: "all",
+			vProps: "all"
+		};
+	}
+	const names = /* @__PURE__ */ new Set();
+	const vAliases = [];
+	const fromRe = /(?:import|export)\s*(?!\s*type\b)(?<clause>(?:\/\*[\s\S]*?\*\/|\/\/[^\n]*|[^;"'])*?)\s*from\s*["']@suzumiyaaoba\/mdxr(?:\/components)?["']/gu;
+	let stripped = source;
+	let vEscapes = false;
+	for (const m of source.matchAll(fromRe)) {
+		const clause = m.groups?.clause ?? "";
+		stripped = stripped.replace(m[0], "");
+		if (!clause.startsWith("{")) return {
+			names: "all",
+			vProps: "all"
+		};
+		const found = vAliases.length;
+		parseClause(clause, names, vAliases);
+		vEscapes ||= m[0].startsWith("export") && vAliases.length > found;
+	}
+	stripped = stripped.replaceAll(/(?:import|export)\s+type\s[^;]*?(?:;|$)/gmu, "");
+	const sep = String.raw`(?:\s|/\*[\s\S]*?\*/|//[^\n]*)*`;
+	if (new RegExp(`import${sep}["']@suzumiyaaoba/mdxr(?:/components)?["']`, "u").test(source) || new RegExp(`import${sep}\\(${sep}["']@suzumiyaaoba/mdxr(?:/components)?["']`, "u").test(source)) return {
+		names: "all",
+		vProps: "all"
+	};
+	const vProps = mergeVProps(stripped, vAliases, vEscapes);
+	return {
+		names,
+		vProps: vAliases.length === 0 ? null : vProps ?? /* @__PURE__ */ new Set()
+	};
+};
+//#endregion
+//#region src/hydrate/runtime-module.ts
+/**
+* The virtual `@suzumiyaaoba/mdxr`(/components) module used inside hydration
+* bundles.
+* A fresh module is generated per importer containing only the re-exports
+* that importer requests: esbuild eagerly resolves every
+* `export { x } from "m"` target, and the leaf modules' top-level
+* `defineComponent(...)` calls count as side effects — so a module exporting
+* the whole catalog would drag the whole catalog into the bundle.
+*/
+/**
+* Names that live outside the leaf map: `builtinComponents` is defined in the
+* catalog barrel itself (pulling it is intentional — the whole catalog is the
+* value) and `defineConfig` is part of the `@suzumiyaaoba/mdxr` API surface.
+* They resolve
+* only when a module actually imports them.
+*/
+const EXTRA_MODULES = {
+	builtinComponents: path.join(srcDir, "ui/index.js"),
+	defineConfig: path.join(srcDir, "config.js"),
+	mountDocument: path.join(srcDir, "hydrate-runtime.js")
+};
+/**
+* The virtual module's `v` export. `export * as v` would materialize the
+* entire valibot namespace — a plain object built from named imports ships
+* only the schemas actually written. Unknown `v.x` accesses stay absent,
+* matching `undefined` semantics. The `surface` gate keeps
+* `@suzumiyaaoba/mdxr/components` honest: that specifier has no `v` export,
+* so shipping one would diverge from SSR.
+*/
+const vExportLines = (imports, surface) => {
+	if (!surface.has("v") || imports.vProps === null) return [];
+	if (imports.vProps === "all" || imports.names === "all") return ["export * as v from \"valibot\";"];
+	const props = [];
+	for (const p of imports.vProps) if (p in valibot) props.push(p);
+	return [props.length > 0 ? `import { ${props.join(", ")} } from "valibot";\nexport const v = { ${props.join(", ")} };` : "export const v = {};"];
+};
+/**
+* Virtual stand-in for `@suzumiyaaoba/mdxr`(/components) inside the bundle.
+*/
+const runtimeModuleContents = (map, imports, surface) => {
+	const lines = [`export { defineComponent, textOf } from ${JSON.stringify(path.join(srcDir, "define.js"))};`, ...vExportLines(imports, surface)];
+	const wanted = imports.names === "all" ? [...surface] : [...imports.names];
+	const byModule = /* @__PURE__ */ new Map();
+	for (const name of wanted) {
+		if (!surface.has(name)) continue;
+		const mod = map.get(name) ?? EXTRA_MODULES[name];
+		if (mod === void 0) continue;
+		const list = byModule.get(mod) ?? [];
+		list.push(name);
+		byModule.set(mod, list);
+	}
+	for (const [mod, mods] of byModule) lines.push(`export { ${mods.join(", ")} } from ${JSON.stringify(mod)};`);
+	return lines.join("\n");
+};
+const runtimeModule = (index) => ({
+	name: "mdxr:runtime",
+	setup(b) {
+		const importers = /* @__PURE__ */ new Map();
+		let seq = 0;
+		b.onResolve({ filter: /^@suzumiyaaoba\/mdxr(?:\/components)?$/ }, (args) => {
+			const virtual = `mdxr:runtime:${seq}`;
+			seq += 1;
+			importers.set(virtual, {
+				importer: args.importer,
+				surface: args.path === "@suzumiyaaoba/mdxr" ? index.surfaces.mdxr : index.surfaces.components
+			});
+			return {
+				namespace: "mdxr-runtime",
+				path: virtual
+			};
+		});
+		b.onLoad({
+			filter: /^mdxr:runtime:/,
+			namespace: "mdxr-runtime"
+		}, async (args) => {
+			const v = importers.get(args.path);
+			return {
+				contents: runtimeModuleContents(index.map, await scanMdxrImports(v?.importer ?? ""), v?.surface ?? index.surfaces.components),
+				loader: "js",
+				resolveDir: srcDir
+			};
+		});
+	}
+});
+//#endregion
+//#region src/hydrate.ts
+/**
+* Hydration bundle assembly: generates the inlined client script that
+* rebuilds the exact vnode tree SSR produced and `hydrateRoot`s it onto
+* `<main id="mdxr-root">`. Implementation details live in `src/hydrate/`:
+* `export-index` (export surface scanning), `import-scan` (user-module
+* import analysis), `runtime-module` (virtual package module codegen), and
+* `plugins` (esbuild plugins for shared packages, the doc module, icons).
+*/
+/**
+* Build the inlined client script: it rebuilds the exact vnode tree SSR
+* produced — `DocContext.Provider` wrapping the Plan header + the compiled
+* MDX module — and `hydrateRoot`s it onto `<main id="mdxr-root">`.
+* `fileLink` is replayed from the recorded SSR answers, so components see
+* identical data without filesystem access.
+*/
+const buildHydrateScript = async (spec) => {
+	const index = await exportIndex();
+	const { map } = index;
+	const imports = [];
+	const entries = [];
+	let seq = 0;
+	const bind = (exported) => {
+		const mod = map.get(exported) ?? EXTRA_MODULES[exported];
+		if (mod === void 0) throw new Error(`hydration: no module provides catalog export "${exported}"`);
+		const local = `__mdxr_c${seq}`;
+		seq += 1;
+		imports.push(`import { ${exported} as ${local} } from ${JSON.stringify(mod)};`);
+		return local;
+	};
+	const mountDocument = bind("mountDocument");
+	const planHeader = spec.header === void 0 ? "undefined" : bind("PlanHeader");
+	for (const name of spec.usedComponents) {
+		if (!Object.hasOwn(builtinComponents, name)) continue;
+		const exported = name === "pre" ? "Pre" : name;
+		entries.push(`${JSON.stringify(name)}: ${bind(exported)}`);
+	}
+	const userImport = spec.componentsPath === void 0 ? "" : `import * as __mdxrUser from ${JSON.stringify(spec.componentsPath)};`;
+	const entry = `${imports.join("\n")}
+${userImport}
+import __mdxrDoc from "mdxr:doc";
+${mountDocument}({
+  components: { ${entries.join(", ")} },
+  doc: __mdxrDoc,
+  fileLinks: ${JSON.stringify(spec.fileLinks)},
+  headerProps: ${JSON.stringify(spec.header)},
+  now: ${JSON.stringify(spec.now)},
+  planHeader: ${planHeader},
+  userModule: ${spec.componentsPath === void 0 ? "undefined" : "__mdxrUser"},
+});
+`;
+	const result = await build({
+		absWorkingDir: pkgRoot,
+		bundle: true,
+		define: { "process.env.NODE_ENV": "\"production\"" },
+		format: "iife",
+		jsx: "automatic",
+		jsxImportSource: "react",
+		logLevel: "silent",
+		metafile: true,
+		minify: true,
+		platform: "browser",
+		plugins: [
+			pinShared,
+			docModule(spec.code),
+			runtimeModule(index),
+			iconSets(spec.usedIcons)
+		],
+		stdin: {
+			contents: entry,
+			loader: "js",
+			resolveDir: pkgRoot,
+			sourcefile: "mdxr-hydrate.js"
+		},
+		target: "es2022",
+		write: false
+	});
+	if (process.env.MDXR_BUNDLE_METAFILE !== void 0) {
+		const { writeFile } = await import("node:fs/promises");
+		await writeFile(process.env.MDXR_BUNDLE_METAFILE, JSON.stringify(result.metafile));
+		await writeFile(`${process.env.MDXR_BUNDLE_METAFILE}.entry.js`, entry);
+	}
+	return result.outputFiles[0]?.text ?? "";
+};
+//#endregion
+//#region src/editor.ts
+/**
+* Path → URI path segment-by-segment. `encodeURI` would leave `#`, `?`,
+* `%`, `&` intact and they parse as delimiters inside the editor URL;
+* `encodeURIComponent` on the whole path would mangle `/`. Backslashes are
+* normalized so Windows paths survive too (`C:\x` → `C%3A/x`).
+*/
+const encodePath = (p) => p.replaceAll("\\", "/").split("/").map((seg) => encodeURIComponent(seg)).join("/");
+/** `scheme://file/{abs}:{line}` — the VS Code URL convention most editors share. */
+const atLine = (scheme) => (p, l) => `${scheme}://file${encodePath(p)}${nonEmpty(l) ? `:${l}` : ""}`;
+/** `{scheme}://open?url=file://{abs}&line={n}` — Sublime/TextMate style. */
+const queryUrl = (scheme) => (p, l) => `${scheme}://open?url=file://${encodePath(p)}${nonEmpty(l) ? `&line=${l}` : ""}`;
+/** Known editors; unknown names fall back to the `scheme://file` convention. */
+const EDITORS = {
+	cursor: atLine("cursor"),
+	idea: (p, l) => `idea://open?file=${encodePath(p)}${nonEmpty(l) ? `&line=${l}` : ""}`,
+	sublime: queryUrl("subl"),
+	textmate: queryUrl("txmt"),
+	vscode: atLine("vscode"),
+	"vscode-insiders": atLine("vscode-insiders"),
+	windsurf: atLine("windsurf"),
+	zed: atLine("zed")
+};
+/**
+* Schemes that execute script when an `<a href>` is clicked. `editor` is a
+* config value, but frontmatter can also supply it — a document must not be
+* able to mint `javascript:`/`data:` links through file references.
+*/
+const SCRIPTABLE = /* @__PURE__ */ new Set([
+	"data",
+	"javascript",
+	"vbscript"
+]);
+const build$1 = (editor, absPath, line) => {
+	const e = nonEmpty(editor) ? editor : "vscode";
+	if (e === "none") return;
+	const known = EDITORS[e];
+	if (known !== void 0) return known(absPath, line);
+	if (e.includes("{path}")) return e.replaceAll("{path}", encodePath(absPath)).replaceAll("{line}", line ?? "");
+	if (!/^[a-z][a-z0-9+.-]*$/iu.test(e)) return;
+	return atLine(e)(absPath, line);
+};
+/**
+* Editor URL for an absolute path. `editor` is a known name (see EDITORS),
+* `"none"` (no link), a URL template with `{path}`/`{line}` placeholders
+* (`myed://open?f={path}&l={line}`), or a bare name treated as a
+* `scheme://file` editor. Undefined → vscode. Scriptable schemes are
+* refused — `editor` can arrive from frontmatter, which is document input.
+*/
+const editorUrl = (editor, absPath, line) => {
+	const url = build$1(editor, absPath, line);
+	if (url === void 0) return;
+	const scheme = urlScheme(url);
+	return scheme !== void 0 && SCRIPTABLE.has(scheme) ? void 0 : url;
+};
+//#endregion
+//#region src/rehype/shiki.ts
+/**
+* Fenced code blocks are syntax-highlighted with shiki at render time.
+* `defaultColor: false` emits `--shiki-light`/`--shiki-dark` CSS variables on
+* every token span; BASE_CSS switches between them via prefers-color-scheme.
+* SKIP_LANGS (langs.ts) are left untouched: mermaid renders as a diagram,
+* terminal langs as a transcript, plain-text aliases stay cheap.
+*/
+const THEMES = {
+	dark: "github-dark",
+	light: "github-light"
+};
+/**
+* A middle ground between startup cost and coverage: grammars in this list are
+* loaded with the highlighter, anything else in shiki's bundle is loaded on
+* first use, and unknown names degrade to unhighlighted code.
+*/
+const PRELOADED_LANGS = [
+	"bash",
+	"c",
+	"cpp",
+	"csharp",
+	"css",
+	"diff",
+	"dockerfile",
+	"go",
+	"graphql",
+	"html",
+	"ini",
+	"java",
+	"javascript",
+	"json",
+	"jsonc",
+	"jsx",
+	"kotlin",
+	"lua",
+	"markdown",
+	"php",
+	"python",
+	"ruby",
+	"rust",
+	"scss",
+	"shell",
+	"sql",
+	"swift",
+	"toml",
+	"tsx",
+	"typescript",
+	"xml",
+	"yaml",
+	"zsh"
+];
+/**
+* Fence-meta tokens that turn line numbers on: ` ```ts ln ` (also accepts
+* `line-numbers` / `lineNumbers` / `showLineNumbers`).
+*/
+const LINE_NUMBER_RE = /(?:^|\s)(?:ln|line-numbers|lineNumbers|showLineNumbers)(?:\s|$)/u;
+/**
+* Transformers shared by every highlighted block. The notation set strips
+* `// [!code …]` markers from the output and tags lines/spans; the meta set
+* reads the fence info string (`{1,3-5}` line ranges, `/word/` matches).
+*/
+const TRANSFORMERS = [
+	transformerNotationDiff(),
+	transformerNotationErrorLevel(),
+	transformerNotationFocus(),
+	transformerNotationHighlight(),
+	transformerNotationWordHighlight(),
+	transformerRemoveNotationEscape(),
+	transformerMetaHighlight(),
+	transformerMetaWordHighlight(),
+	{
+		name: "mdxr:line-numbers",
+		pre(node) {
+			const raw = this.options.meta?.__raw ?? "";
+			if (LINE_NUMBER_RE.test(raw)) this.addClassToHast(node, "has-line-numbers");
+		}
+	}
+];
+let highlighterPromise;
+const getHighlighter = async () => {
+	highlighterPromise ??= createHighlighter({
+		langs: [...PRELOADED_LANGS],
+		themes: [THEMES.light, THEMES.dark]
+	});
+	try {
+		return await highlighterPromise;
+	} catch (error) {
+		highlighterPromise = void 0;
+		throw error;
+	}
+};
+const DIFF_FENCE_LANGS = /* @__PURE__ */ new Set(["diff", "patch"]);
+const isElement = (node) => isRecord(node) && node.type === "element" && typeof node.tagName === "string";
+/** mdast-sourced nodes use `className`; shiki's hast uses `class`. Read both. */
+const classNames = (el) => {
+	const c = el?.properties?.className ?? el?.properties?.class;
+	if (typeof c === "string") return c.split(/\s+/u).filter(Boolean);
+	return Array.isArray(c) ? c.map(String) : [];
+};
+const textContent$1 = (node) => {
+	if (node.type === "text") return node.value;
+	return "children" in node ? node.children.map(textContent$1).join("") : "";
+};
+const languageOf = (code) => /language-(?<lang>[^\s]+)/u.exec(classNames(code).join(" "))?.groups?.lang;
+/** In-flight grammar loads, deduplicated across concurrent code blocks. */
+const langLoads = /* @__PURE__ */ new Map();
+/** Lazily loads a grammar; resolves false when shiki doesn't know the name. */
+const ensureLanguage = async (highlighter, lang) => {
+	if (highlighter.getLoadedLanguages().includes(lang)) return true;
+	const pending = langLoads.get(lang);
+	if (pending !== void 0) return await pending;
+	const load = (async () => {
+		const bundled = highlighter.getBundledLanguages();
+		const loader = own(bundled, lang);
+		if (loader === void 0) return false;
+		await highlighter.loadLanguage(loader);
+		return highlighter.getLoadedLanguages().includes(lang);
+	})();
+	langLoads.set(lang, load);
+	try {
+		return await load;
+	} finally {
+		langLoads.delete(lang);
+	}
+};
+/**
+* The highlighter when `lang` can be handled — undefined for SKIP_LANGS and
+* names shiki doesn't know, so callers degrade to unhighlighted code.
+*/
+const readyHighlighter = async (lang) => {
+	if (SKIP_LANGS.has(lang)) return;
+	try {
+		const highlighter = await getHighlighter();
+		return await ensureLanguage(highlighter, lang) ? highlighter : void 0;
+	} catch {
+		return;
+	}
+};
+/**
+* One side of a hunk, highlighted as the file's own language: `ctx`/`add`
+* rows read from the new side, `ctx`/`del` rows from the old side. Shiki's
+* output line array aligns 1:1 with the joined row texts (rows never
+* contain `\n`).
+*/
+const sideTokens = (highlighter, lang, src) => {
+	if (src === "") return [];
+	const code = highlighter.codeToHast(src, {
+		defaultColor: false,
+		lang,
+		themes: THEMES
+	}).children.find((child) => isElement(child) && child.tagName === "pre")?.children.find((child) => isElement(child) && child.tagName === "code");
+	if (code === void 0) return [];
+	const lines = [];
+	for (const child of code.children) {
+		if (!isElement(child) || child.tagName !== "span" || !classNames(child).includes("line")) continue;
+		lines.push(child.children.flatMap((tok) => {
+			if (tok.type === "text") return tok.value === "" ? [] : [{ t: tok.value }];
+			if (!isElement(tok)) return [];
+			const style = tok.properties?.style;
+			return [{
+				s: typeof style === "string" && style !== "" ? style : void 0,
+				t: textContent$1(tok)
+			}];
+		}));
+	}
+	return lines;
+};
+/** Token lines per row of one hunk — `null` for note rows and for rows whose
+* side had no usable grammar. Add/ctx rows read the new-side highlight, del
+* rows the old-side one (the sides can carry different languages after a
+* cross-extension rename). */
+const hunkTokens = (sides, rows) => {
+	const nt = sides.new === void 0 ? [] : sideTokens(sides.new.highlighter, sides.new.lang, rows.filter((r) => r.kind === "ctx" || r.kind === "add").map((r) => r.text).join("\n"));
+	const ot = sides.old === void 0 ? [] : sideTokens(sides.old.highlighter, sides.old.lang, rows.filter((r) => r.kind === "ctx" || r.kind === "del").map((r) => r.text).join("\n"));
+	let ni = 0;
+	let oi = 0;
+	return rows.map((row) => {
+		if (row.kind === "add") {
+			const t = nt[ni] ?? null;
+			ni += 1;
+			return t;
+		}
+		if (row.kind === "del") {
+			const t = ot[oi] ?? null;
+			oi += 1;
+			return t;
+		}
+		if (row.kind === "ctx") {
+			const t = nt[ni] ?? null;
+			ni += 1;
+			oi += 1;
+			return t;
+		}
+		return null;
+	});
+};
+/**
+* Language-highlighted rows for every file/hunk of a parsed diff. Language
+* comes from the `lang=` meta override, else the file's own path (the fence's
+* `title=`/`filename=` names a single-file diff). A file whose language can't
+* be resolved keeps `null` rows — it renders plain, like today.
+*/
+const diffHighlight = async (files, meta) => {
+	const override = fenceLang(meta);
+	const named = files.length === 1 ? fenceFilename(meta) : void 0;
+	const langOf = (path) => override ?? (path === void 0 ? void 0 : langForPath(path));
+	const perFile = files.map((file) => ({
+		file,
+		newLang: langOf(file.newPath ?? file.oldPath ?? named),
+		oldLang: langOf(file.oldPath ?? file.newPath ?? named)
+	}));
+	const wanted = new Set(perFile.flatMap((l) => [l.newLang, l.oldLang].filter((x) => x !== void 0)));
+	const ready = /* @__PURE__ */ new Map();
+	await Promise.all([...wanted].map(async (lang) => {
+		const highlighter = await readyHighlighter(lang);
+		if (highlighter !== void 0) ready.set(lang, highlighter);
+	}));
+	const sideOf = (lang) => {
+		if (lang === void 0) return;
+		const highlighter = ready.get(lang);
+		return highlighter === void 0 ? void 0 : {
+			highlighter,
+			lang
+		};
+	};
+	let any = false;
+	const hl = perFile.map(({ file, newLang, oldLang }) => {
+		const newSide = sideOf(newLang);
+		const oldSide = sideOf(oldLang) ?? newSide;
+		return file.hunks.map((h) => {
+			try {
+				const rows = hunkTokens({
+					new: newSide,
+					old: oldSide
+				}, h.rows);
+				any ||= rows.some((r) => r !== null);
+				return rows;
+			} catch {
+				return h.rows.map(() => null);
+			}
+		});
+	});
+	return any ? hl : void 0;
+};
+/**
+* Rehype plugin: replace the text inside `pre > code` with shiki's highlighted
+* line spans. The `pre`/`code` elements and their properties (language class,
+* `meta` from remarkCodeMeta) are kept so the `Pre` component's filename
+* header, copy payload, and mermaid handling keep working. ```diff/```patch
+* fences skip the generic path: `DiffView` replaces their markup, so instead
+* each hunk's old/new sides are highlighted in the file's own language and
+* parked as JSON on `code`'s `data-diffhl` prop — it serializes into the
+* compiled module, reaching SSR and hydration renders identically.
+*/
+const rehypeShiki = () => async (tree) => {
+	const targets = [];
+	const diffs = [];
+	visit(tree, "element", (node) => {
+		if (node.tagName !== "pre") return;
+		const code = node.children[0];
+		if (!isElement(code) || code.tagName !== "code") return;
+		const lang = languageOf(code);
+		if (lang === void 0 || SKIP_LANGS.has(lang)) return;
+		const meta = typeof code.properties?.meta === "string" ? code.properties.meta : "";
+		const text = textContent$1(code);
+		if (DIFF_FENCE_LANGS.has(lang)) {
+			const files = parseDiff(text).filter((f) => f.raw.length > 0);
+			if (files.length > 0) {
+				diffs.push({
+					code,
+					files,
+					meta
+				});
+				return;
+			}
+		}
+		targets.push({
+			code,
+			lang,
+			meta,
+			text
+		});
+	});
+	if (targets.length === 0 && diffs.length === 0) return;
+	await Promise.all([...targets.map(async ({ code, lang, meta, text }) => {
+		const highlighter = await readyHighlighter(lang);
+		if (highlighter === void 0) return;
+		let hast;
+		try {
+			hast = highlighter.codeToHast(text.replace(/\n$/u, ""), {
+				defaultColor: false,
+				lang,
+				meta: { __raw: meta },
+				themes: THEMES,
+				transformers: TRANSFORMERS
+			});
+		} catch {
+			return;
+		}
+		const shikiPre = hast.children.find((child) => isElement(child) && child.tagName === "pre");
+		const highlightedCode = shikiPre?.children[0];
+		if (!isElement(highlightedCode) || highlightedCode.tagName !== "code") return;
+		code.children = highlightedCode.children;
+		const lifted = classNames(shikiPre).filter((c) => c.startsWith("has-"));
+		code.properties = {
+			...code.properties,
+			className: [
+				...classNames(code),
+				"shiki",
+				...lifted
+			]
+		};
+	}), ...diffs.map(async ({ code, files, meta }) => {
+		const hl = await diffHighlight(files, meta);
+		if (hl === void 0) return;
+		code.properties = {
+			...code.properties,
+			"data-diffhl": JSON.stringify(hl)
+		};
+	})]);
+};
+//#endregion
+//#region src/remark/ast.ts
+const isParent = (n) => "children" in n && Array.isArray(n.children);
+const isFlowElement = (n) => n.type === "mdxJsxFlowElement";
+/** All literal text under `node`, concatenated in tree order — `inlineCode`
+* carries its code in `value` too, and dropping it would truncate heading
+* slugs and directive labels at the first backtick span. */
+const textContent = (node) => {
+	let out = "";
+	visit(node, ["text", "inlineCode"], (n) => {
+		if ("value" in n && typeof n.value === "string") out += n.value;
+	});
+	return out;
+};
+/** A JSX attribute's string value, or undefined when absent/empty/non-string. */
+const jsxAttr = (node, name) => {
+	if (!Array.isArray(node.attributes)) return;
+	for (const a of node.attributes) if (isRecord(a) && a.name === name && typeof a.value === "string" && a.value !== "") return a.value;
+};
+/**
+* `Record` → `mdxJsxAttribute[]`. null/undefined/"" values are dropped —
+* MDX attributes arrive as strings, so everything is `String()`-coerced.
+*/
+const jsxAttrs = (attrs) => Object.entries(attrs).filter(([, val]) => val !== null && val !== void 0 && val !== "").map(([key, val]) => ({
+	name: key,
+	type: "mdxJsxAttribute",
+	value: String(val)
+}));
+/** Mutate `node` into an `mdxJsxFlowElement`/`mdxJsxTextElement` in place. */
+const toMdxElement = (node, kind, name, attrs) => {
+	node.type = kind;
+	node.name = name;
+	node.attributes = jsxAttrs(attrs);
+};
+/**
+* Merge `key: value` into `node.data.hProperties` (creating both levels).
+* The mdast→hast bridge turns hProperties into element props.
+*/
+const setHProperty = (node, key, value) => {
+	const data = isRecord(node.data) ? node.data : {};
+	node.data = data;
+	data.hProperties = {
+		...isRecord(data.hProperties) ? data.hProperties : {},
+		[key]: value
+	};
+};
+//#endregion
+//#region src/remark/callouts.ts
+/** Callout kinds shared by `:::kind` directives and `> [!KIND]` alerts. */
+const CALLOUT_KINDS = /* @__PURE__ */ new Set([
+	"note",
+	"tip",
+	"important",
+	"warning",
+	"caution",
+	"danger",
+	"decision",
+	"goal",
+	"nongoal",
+	"question",
+	"answer"
+]);
+/** Lowercases and maps the `non-goal`/`nongoal` spellings to `nongoal`. */
+const normalizeCalloutKind = (kind) => kind.toLowerCase().replace(/^non-goal$/u, "nongoal");
+/** GitHub alert marker: `> [!WARNING]` — kinds derived from CALLOUT_KINDS. */
+const ALERT_RE = new RegExp(`^\\[!(?<kind>${[...CALLOUT_KINDS].map((k) => k === "nongoal" ? "non-?goal" : k).join("|")})\\]\\s*`, "iu");
+//#endregion
+//#region src/remark/alerts.ts
+/** A text node with a mutable string `value` — callers edit it in place. */
+const isTextValue = (n) => n !== void 0 && n.type === "text" && "value" in n && typeof n.value === "string";
+/**
+* GitHub-style alerts become Callout components:
+*   > [!WARNING]
+*   > Be careful.
+* renders identically to <Callout kind="warning">.
+*/
+const remarkMdxrAlerts = () => (tree) => {
+	visit(tree, "blockquote", (node) => {
+		if (!isParent(node)) return;
+		const [first] = node.children;
+		if (first === void 0 || first.type !== "paragraph" || !isParent(first)) return;
+		const [text] = first.children;
+		if (!isTextValue(text)) return;
+		const m = ALERT_RE.exec(text.value);
+		if (m === null || m.groups === void 0) return;
+		const rest = text.value.slice(m[0].length);
+		text.value = rest;
+		if (rest === "") first.children.shift();
+		if (first.children.length === 0) node.children.shift();
+		toMdxElement(node, "mdxJsxFlowElement", "Callout", { kind: normalizeCalloutKind(m.groups.kind) });
+	});
+};
+//#endregion
+//#region src/remark/code-file.ts
+/**
+* `<CodeFile path="src/foo.ts" lines="40-52" lang="ts" />` embeds a real file
+* from disk as a fenced code block, so code explanations quote the actual
+* source instead of drifting copies. `path` resolves relative to the
+* document; `lines` slices a 1-based range; `lang` overrides the extension.
+* The emitted `code` node carries `title="…"` meta so `remarkCodeMeta` /
+* `Pre` render the usual filename header — run this before remarkCodeMeta.
+*/
+const remarkCodeFile = () => (tree, file) => {
+	visit(tree, "mdxJsxFlowElement", (node) => {
+		if (!isFlowElement(node) || node.name !== "CodeFile") return;
+		const rel = jsxAttr(node, "path");
+		if (rel === void 0) file.fail("<CodeFile> requires a `path` attribute", node, "mdxr:code-file");
+		const abs = path.resolve(file.dirname ?? ".", rel);
+		let content;
+		try {
+			content = readFileSync(abs, "utf-8");
+		} catch {
+			file.fail(`<CodeFile> cannot read ${rel}`, node, "mdxr:code-file");
+		}
+		const rangeSpec = jsxAttr(node, "lines");
+		let titleSuffix = "";
+		if (rangeSpec !== void 0) {
+			const range = parseLineRange(rangeSpec);
+			if (range === void 0) file.fail(`<CodeFile> invalid lines range: ${rangeSpec}`, node, "mdxr:code-file");
+			const all = content.replace(/\n$/u, "").split("\n");
+			if (range.start > all.length) file.fail(`<CodeFile> lines ${rangeSpec} out of range (${all.length} lines in ${rel})`, node, "mdxr:code-file");
+			content = all.slice(range.start - 1, range.end).join("\n");
+			titleSuffix = `:${rangeSpec}`;
+		}
+		const lang = jsxAttr(node, "lang") ?? langForPath(abs);
+		const target = node;
+		target.type = "code";
+		delete target.name;
+		delete target.attributes;
+		delete target.children;
+		target.lang = lang;
+		target.meta = `title="${rel.replaceAll("\"", "'")}${titleSuffix}"`;
+		target.value = content;
+	});
+};
+//#endregion
+//#region src/remark/code-meta.ts
+/**
+* The mdast→hast conversion drops the code fence info string (`meta`).
+* Copy it to `hProperties.meta` so it reaches the `pre` element's props.
+*/
+const remarkCodeMeta = () => (tree) => {
+	visit(tree, "code", (node) => {
+		if (!("meta" in node) || typeof node.meta !== "string" || node.meta === "") return;
+		setHProperty(node, "meta", node.meta);
+	});
+};
+//#endregion
+//#region src/remark/directives.ts
+const CONTAINER_COMPONENTS = {
+	audit: "Audit",
+	barchart: "BarChart",
+	bench: "Bench",
+	benchmarks: "Benchmarks",
+	board: "Board",
+	bridge: "Bridge",
+	bump: "Bump",
+	bumps: "Bumps",
+	check: "Check",
+	checks: "Checks",
+	comment: "Comment",
+	comments: "Comments",
+	day: "Day",
+	dbfield: "DbField",
+	dbtable: "DbTable",
+	deps: "Deps",
+	endpoints: "Endpoints",
+	entry: "Entry",
+	envvar: "EnvVar",
+	envvars: "EnvVars",
+	files: "Files",
+	finding: "Finding",
+	findings: "Findings",
+	flow: "Flow",
+	funnel: "Funnel",
+	gantt: "Gantt",
+	gauge: "Gauge",
+	gauges: "Gauges",
+	graph: "Graph",
+	hypotheses: "Hypotheses",
+	hypothesis: "Hypothesis",
+	incident: "Incident",
+	linechart: "LineChart",
+	matrix: "Matrix",
+	package: "Package",
+	packages: "Packages",
+	pathway: "Pathway",
+	phase: "Phase",
+	piechart: "PieChart",
+	plan: "Plan",
+	quadrant: "Quadrant",
+	radar: "Radar",
+	release: "Release",
+	review: "Review",
+	sankey: "Sankey",
+	scatter: "Scatter",
+	schema: "Schema",
+	search: "Search",
+	searches: "Searches",
+	service: "Service",
+	statuspage: "StatusPage",
+	steps: "Steps",
+	stop: "Stop",
+	summary: "Summary",
+	terminal: "Terminal",
+	tests: "Tests",
+	timeline: "Timeline",
+	toc: "Toc",
+	trace: "Trace",
+	treemap: "Treemap",
+	uptime: "Uptime",
+	venn: "Venn",
+	verdict: "Verdict",
+	vuln: "Vuln",
+	waterfall: "Waterfall"
+};
+const isDirective = (n) => "name" in n && typeof n.name === "string" && "attributes" in n && isRecord(n.attributes) && isParent(n);
+/**
+* remark-directive containers become mdxr components:
+*   :::note[Optional label]        → <Callout kind="note" title="Optional label">
+*   :::phase{title="X" status="doing"} → <Phase title="X" status="doing">
+*   :::plan / :::steps / :::summary / :::timeline → Plan / Steps / Summary / Timeline
+*   :::flow / :::findings / :::finding / :::files / :::deps
+*     → Flow / Findings / Finding / Files / Deps
+*   :::terminal / :::trace / :::hypotheses / :::hypothesis / :::searches / :::search
+*     → Terminal / Trace / Hypotheses / Hypothesis / Searches / Search
+*   :::barchart / :::linechart / :::piechart / :::scatter / :::radar
+*     → BarChart / LineChart / PieChart / Scatter / Radar
+*   :::funnel / :::quadrant / :::bridge / :::treemap / :::sankey / :::venn
+*     → Funnel / Quadrant / Bridge / Treemap / Sankey / Venn
+*   :::review / :::comment / :::checks / :::check / :::audit / :::vuln
+*     → Review / Comment / Checks / Check / Audit / Vuln
+*   :::bumps / :::bump / :::packages / :::package
+*     → Bumps / Bump / Packages / Package
+*   :::gauges / :::gauge / :::benchmarks / :::bench
+*     → Gauges / Gauge / Benchmarks / Bench
+*   :::schema / :::dbtable / :::dbfield / :::envvars / :::envvar
+*     → Schema / DbTable / DbField / EnvVars / EnvVar
+*   :::release / :::entry / :::pathway / :::stop / :::incident / :::verdict
+*     → Release / Entry / Pathway / Stop / Incident / Verdict
+*   :::statuspage / :::service / :::uptime / :::day
+*     → StatusPage / Service / Uptime / Day
+* `non-goal` is accepted as an alias of the `nongoal` callout kind.
+*/
+const remarkMdxrDirectives = () => (tree, file) => {
+	visit(tree, [
+		"containerDirective",
+		"leafDirective",
+		"textDirective"
+	], (node) => {
+		if (!isDirective(node)) return;
+		const directive = node;
+		const name = normalizeCalloutKind(directive.name);
+		const isContainer = directive.type === "containerDirective";
+		const container = own(CONTAINER_COMPONENTS, name);
+		const component = CALLOUT_KINDS.has(name) ? "Callout" : container;
+		if (component === void 0) {
+			file.message(`Unknown directive ":::${directive.name}"`, directive, "mdxr:directives");
+			return;
+		}
+		if (!isContainer) {
+			file.message(`:::${directive.name} is a container directive — use three colons`, directive, "mdxr:directives");
+			return;
+		}
+		const attrs = { ...directive.attributes };
+		const [first] = directive.children;
+		if (first !== void 0 && isRecord(first.data) && first.data.directiveLabel === true) {
+			attrs.title ??= textContent(first).trim();
+			directive.children.shift();
+		}
+		if (component === "Callout") toMdxElement(directive, "mdxJsxFlowElement", "Callout", {
+			kind: name,
+			...attrs
+		});
+		else toMdxElement(directive, "mdxJsxFlowElement", component, attrs);
+	});
+};
+//#endregion
+//#region src/remark/file-paths.ts
+/**
+* Inline code that names a real file path — `` `src/mdx.ts` `` — becomes a
+* `<FileRef>` chip, so prose references get the same editor link, icon, and
+* copy button as an explicit component. The value must contain a `/` (a bare
+* `file.ts` stays code) and resolve to an existing file relative to the
+* document; a trailing `:N`/`:N-M` becomes `lines`. Paths inside links are
+* left alone — a chip can't nest inside <a>. Runs late in the pipeline so
+* directive labels and heading slugs are already computed.
+*/
+const remarkFilePaths = () => (tree, file) => {
+	const dir = file.dirname ?? ".";
+	const resolve = (value) => {
+		if (!value.includes("/") || value.includes("://")) return;
+		const target = splitPathLines(value);
+		if (existsSync(path.resolve(dir, target.path))) return target;
+		return target.lines !== void 0 && existsSync(path.resolve(dir, value)) ? { path: value } : void 0;
+	};
+	visitParents(tree, "inlineCode", (node, ancestors) => {
+		if (ancestors.some((a) => a.type === "link" || a.type === "linkReference" || (a.type === "mdxJsxTextElement" || a.type === "mdxJsxFlowElement") && a.name === "a") || !("value" in node) || typeof node.value !== "string") return;
+		const target = resolve(node.value);
+		if (target === void 0) return;
+		const el = node;
+		toMdxElement(el, "mdxJsxTextElement", "FileRef", {
+			lines: target.lines,
+			path: target.path
+		});
+		el.children = [];
+		delete el.value;
+	});
+};
+//#endregion
+//#region src/remark/headings.ts
+const isHeading = (n) => n.type === "heading";
+/** GitHub-style slug: lowercase, punctuation stripped, spaces → `-`. */
+const slugify = (text) => text.toLowerCase().trim().replaceAll(/[^\p{L}\p{N}_\s-]/gu, "").replaceAll(/\s+/gu, "-");
+/** Positive-int attribute or fallback — "0"/"abc" both become `fallback`. */
+const depthAttr = (node, name, fallback) => {
+	const raw = jsxAttr(node, name);
+	const n = Number(raw);
+	return raw === void 0 || !Number.isInteger(n) || n < 1 ? fallback : n;
+};
+/** Nest a flat heading list by depth (an h3 under the previous h2, …). */
+const nest = (headings) => {
+	const roots = [];
+	const stack = [];
+	for (const h of headings) {
+		while (stack.length > 0 && (stack.at(-1)?.depth ?? 0) >= h.depth) stack.pop();
+		const parent = stack.at(-1);
+		if (parent === void 0) roots.push(h);
+		else parent.children.push(h);
+		stack.push(h);
+	}
+	return roots;
+};
+const toList = (items) => ({
+	children: items.map((item) => ({
+		children: [{
+			children: [{
+				children: [{
+					type: "text",
+					value: item.text
+				}],
+				type: "link",
+				url: `#${item.slug}`
+			}],
+			type: "paragraph"
+		}, ...item.children.length > 0 ? [toList(item.children)] : []],
+		spread: false,
+		type: "listItem"
+	})),
+	ordered: false,
+	spread: false,
+	type: "list"
+});
+/**
+* Two jobs, one pass over the document:
+* 1. Every heading gets an `id` (GitHub-style slug, deduplicated), enabling
+*    deep links.
+* 2. `<Toc>` elements (`:::toc` included) get a nested link list injected as
+*    children — `depth`/`min` attributes bound the heading levels included
+*    (defaults: h2–h3, i.e. min=2 depth=3).
+*/
+const remarkMdxrHeadings = () => (tree) => {
+	const counts = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Set();
+	const headings = [];
+	visit(tree, "heading", (node) => {
+		if (!isHeading(node)) return;
+		const text = textContent(node).trim();
+		const base = slugify(text) || "section";
+		let count = counts.get(base) ?? 0;
+		let slug = count === 0 ? base : `${base}-${count}`;
+		while (used.has(slug)) {
+			count += 1;
+			slug = `${base}-${count}`;
+		}
+		counts.set(base, count + 1);
+		used.add(slug);
+		setHProperty(node, "id", slug);
+		headings.push({
+			children: [],
+			depth: node.depth,
+			slug,
+			text
+		});
+	});
+	visit(tree, "mdxJsxFlowElement", (node) => {
+		if (!isFlowElement(node) || node.name !== "Toc") return;
+		const minDepth = depthAttr(node, "min", 2);
+		const maxDepth = depthAttr(node, "depth", 3);
+		const items = headings.filter((h) => h.depth >= minDepth && h.depth <= maxDepth && h.text !== "");
+		node.children = items.length === 0 ? [] : [toList(nest(items))];
+	});
+};
+//#endregion
+//#region src/remark/no-js.ts
+const JS_NODES = [
+	"mdxjsEsm",
+	"mdxFlowExpression",
+	"mdxTextExpression"
+];
+const JSX_ELEMENTS = ["mdxJsxFlowElement", "mdxJsxTextElement"];
+const MESSAGE = "JavaScript expressions and import/export statements are not allowed in mdxr documents. Add a component via mdxr.config.ts instead.";
+/**
+* mdxr documents are data, not code: reject ESM imports/exports and JS
+* expressions (`{...}`) — including inside JSX attributes (`prop={x}`,
+* `{...spread}`), which `visit` never reaches because attributes are not
+* children. Extensibility happens through mdxr.config.ts, not through
+* executable markup inside the document.
+*/
+const remarkNoJs = () => (tree, file) => {
+	visit(tree, JS_NODES, (node) => {
+		file.fail(MESSAGE, node, "mdxr:no-js");
+	});
+	visit(tree, JSX_ELEMENTS, (node) => {
+		if (!("attributes" in node) || !Array.isArray(node.attributes)) return;
+		for (const attr of node.attributes) if (isRecord(attr) && (attr.type !== "mdxJsxAttribute" || attr.value !== null && typeof attr.value !== "string")) file.fail(MESSAGE, node, "mdxr:no-js");
+	});
+};
+//#endregion
+//#region src/mdx.ts
+/**
+* Which catalog entries the document references is visible in the compiled
+* module itself: JSX identifiers become `_missingMdxReference("Name", …)`
+* checks, markdown element overrides read `_components.name`, and a `wrapper`
+* entry is picked straight off `props.components`. (Spreading `components`
+* into `_components` makes runtime tracking see every key — hence static
+* extraction here instead.)
+*/
+const extractUsedComponents = (code, components) => {
+	const catalogKeys = new Set(Object.keys(components));
+	const used = /* @__PURE__ */ new Set();
+	for (const m of code.matchAll(/_missingMdxReference\("(?<name>[^"]+)"/gu)) {
+		const name = m.groups?.name;
+		if (name !== void 0 && catalogKeys.has(name)) used.add(name);
+	}
+	for (const m of code.matchAll(/_components\.(?<dot>\w+)|_components\["(?<bracket>[^"]+)"\]/gu)) {
+		const name = m.groups?.dot ?? m.groups?.bracket;
+		if (name !== void 0 && catalogKeys.has(name)) used.add(name);
+	}
+	if (catalogKeys.has("wrapper")) used.add("wrapper");
+	return [...used];
+};
+const mdxToHtml = async (source, components, filePath = "document.mdx", opts = {}) => {
+	const file = new VFile({
+		path: filePath,
+		value: source
+	});
+	matter(file);
+	const fmRaw = isRecord(file.data) ? file.data.matter : void 0;
+	const frontmatter = isRecord(fmRaw) ? fmRaw : {};
+	const editor = typeof frontmatter.editor === "string" && frontmatter.editor !== "" ? frontmatter.editor : opts.editor;
+	const dir = file.dirname ?? ".";
+	const fileLinks = /* @__PURE__ */ new Map();
+	const fileLink = (rel, line) => {
+		const abs = path.resolve(dir, rel);
+		const url = existsSync(abs) ? editorUrl(editor, abs, line) : void 0;
+		if (url !== void 0) fileLinks.set(`${rel}\0${line ?? ""}`, url);
+		return url;
+	};
+	const compiled = await compile(file, {
+		baseUrl: import.meta.url,
+		format: "mdx",
+		rehypePlugins: [rehypeKatex, rehypeShiki],
+		remarkPlugins: [
+			remarkFrontmatter,
+			remarkGfm,
+			remarkMath,
+			remarkDirective,
+			remarkMdxrDirectives,
+			remarkMdxrAlerts,
+			remarkNoJs,
+			remarkMdxrHeadings,
+			remarkCodeFile,
+			remarkCodeMeta,
+			remarkFilePaths
+		]
+	});
+	for (const m of compiled.messages) process.stderr.write(`mdxr: warning: ${formatError(m)}\n`);
+	const code = String(compiled);
+	const mod = await importBundledCode(code, "doc");
+	const used = extractUsedComponents(code, components);
+	const docComponent = mod.default;
+	if (!isComponent(docComponent)) throw new Error("Compiled document has no default export component.");
+	takeUsedIcons();
+	const renderedAt = /* @__PURE__ */ new Date();
+	const context = {
+		fileLink,
+		now: renderedAt
+	};
+	const hydrated = (opts.hydrate ?? true) && used.length > 0;
+	const renderToMarkup = hydrated ? renderToString : renderToStaticMarkup;
+	const renderDocument = (header) => renderToMarkup(createElement(DocContext.Provider, { value: context }, createElement(Fragment, null, header, createElement(docComponent, { components }))));
+	let body;
+	try {
+		body = renderDocument(null);
+	} catch (error) {
+		throw enhanceRenderError(error, Object.keys(components));
+	}
+	return {
+		body,
+		code,
+		context,
+		fileLinks: Object.fromEntries(fileLinks),
+		frontmatter,
+		hydrated,
+		renderWithHeader: (header) => {
+			try {
+				const html = renderDocument(header);
+				return {
+					fileLinks: Object.fromEntries(fileLinks),
+					html,
+					usedIcons: takeUsedIcons()
+				};
+			} catch (error) {
+				throw enhanceRenderError(error, Object.keys(components));
+			}
+		},
+		renderedAt: renderedAt.toISOString(),
+		usedComponents: used,
+		usedIcons: takeUsedIcons()
+	};
+};
+//#endregion
+//#region src/assets/css.ts
+/** Base CSS appended after Tailwind utilities (covers what utilities can't). */
+const BASE_CSS = `
+/* Preflight makes <svg> display:block, which splits inline text around
+ * icons; Iconify svgs (.iconify) and lucide-react svgs (.lucide) stay inline. */
+.iconify, .lucide { display: inline-block; }
+.task-list-item { list-style: none; }
+ul.contains-task-list { padding-left: 1.25rem; }
+.task-list-item input[type='checkbox'] { margin-right: 0.4em; }
+/* --- Interaction feedback -------------------------------------------
+ * Every [data-copy] button carries an idle and a done icon
+ * (.mdxr-copy-idle/.mdxr-copy-done); the delegated event handler
+ * (src/client, also bound in the Storybook preview) toggles
+ * .copied/.copy-failed for ~1.6s after each clipboard attempt. Success
+ * swaps the copy icon for an emerald check with a pop; failure shakes and
+ * tints red; pressing the button scales it down briefly. */
+.mdxr-copy {
+  display: inline-flex; align-items: center; justify-content: center;
+  border-radius: 0.25rem;
+  transition: opacity 0.15s ease, color 0.15s ease, transform 0.1s ease;
+}
+.mdxr-copy:hover { opacity: 1; }
+.mdxr-copy:active { transform: scale(0.82); }
+.mdxr-copy:focus-visible {
+  outline: 2px solid rgb(14 165 233); outline-offset: 1px; opacity: 1;
+}
+.mdxr-copy.copied, .mdxr-copy.copy-failed { opacity: 1; }
+.mdxr-copy.copy-failed { color: rgb(220 38 38); }
+.dark .mdxr-copy.copy-failed { color: rgb(248 113 113); }
+/* Theme toggle: fixed corner chrome injected by htmlDocument. Cycles
+ * auto → light → dark; [data-mode] picks which icon shows. */
+.mdxr-theme {
+  position: fixed; top: 0.75rem; right: 0.75rem; z-index: 50;
+  display: inline-flex; align-items: center; justify-content: center;
+  height: 2rem; width: 2rem; margin: 0; padding: 0; border-radius: 9999px;
+  border: 1px solid rgb(229 229 229); color: rgb(82 82 82);
+  background: rgb(255 255 255 / 0.85); backdrop-filter: blur(8px);
+  cursor: pointer;
+  transition: color 0.15s ease, background-color 0.15s ease,
+    border-color 0.15s ease, transform 0.1s ease;
+}
+.mdxr-theme:hover { color: rgb(23 23 23); background: rgb(255 255 255); }
+.mdxr-theme:active { transform: scale(0.88); }
+.mdxr-theme:focus-visible {
+  outline: 2px solid rgb(14 165 233); outline-offset: 2px;
+}
+.dark .mdxr-theme {
+  border-color: rgb(64 64 64); color: rgb(163 163 163);
+  background: rgb(23 23 23 / 0.85);
+}
+.dark .mdxr-theme:hover { color: rgb(250 250 250); background: rgb(23 23 23); }
+.mdxr-theme .mdxr-theme-i { display: none; }
+.mdxr-theme[data-mode="auto"] .mdxr-theme-i-auto,
+.mdxr-theme[data-mode="light"] .mdxr-theme-i-light,
+.mdxr-theme[data-mode="dark"] .mdxr-theme-i-dark {
+  display: inline-flex;
+  animation: mdxr-pop 0.28s cubic-bezier(0.34, 1.56, 0.64, 1);
+}
+.mdxr-theme svg { height: 1rem; width: 1rem; }
+@media print { .mdxr-theme { display: none; } }
+.mdxr-copy-done { display: none; }
+.copied .mdxr-copy-idle { display: none; }
+.copied .mdxr-copy-done {
+  display: inline-flex;
+  animation: mdxr-pop 0.28s cubic-bezier(0.34, 1.56, 0.64, 1);
+}
+.copy-failed { animation: mdxr-shake 0.32s ease; }
+[data-ask-copy].copy-failed, [data-ask-save].copy-failed {
+  border-color: rgb(248 113 113); color: rgb(220 38 38);
+}
+.dark [data-ask-copy].copy-failed, .dark [data-ask-save].copy-failed {
+  color: rgb(248 113 113);
+}
+.mdxr-ask [data-ask-copy].copied, .mdxr-ask [data-ask-save].copied {
+  border-color: rgb(52 211 153 / 0.6);
+}
+/* Board: cards drag between lanes (and reorder within one). .mdxr-drag
+ * marks the card being held; .mdxr-drop-before (on a card) and
+ * .mdxr-drop-end (on the lane's card box) draw the insertion line;
+ * .mdxr-drop-lane outlines the target lane. The ‹ › move buttons stay
+ * visible at low opacity — they're the touch/keyboard path (HTML5 DnD
+ * never reaches touch browsers). */
+[data-board-card] { cursor: grab; }
+[data-board-card].mdxr-drag { cursor: grabbing; opacity: 0.4; }
+[data-board-card].mdxr-drop-before { box-shadow: 0 -2px 0 0 rgb(14 165 233); }
+[data-board-cards].mdxr-drop-end {
+  box-shadow: inset 0 -2px 0 0 rgb(14 165 233);
+  border-radius: 0.375rem;
+}
+[data-board-lane].mdxr-drop-lane {
+  outline: 2px dashed rgb(14 165 233 / 0.5);
+  outline-offset: -2px;
+}
+.mdxr-move {
+  display: inline-flex; align-items: center; justify-content: center;
+  height: 1.25rem; width: 1.25rem; border: 0; padding: 0;
+  border-radius: 0.25rem; background: transparent;
+  color: rgb(163 163 163); cursor: pointer; opacity: 0.6;
+  transition: opacity 0.15s ease, color 0.15s ease,
+    background-color 0.15s ease, transform 0.1s ease;
+}
+.mdxr-move:not(:disabled):hover {
+  opacity: 1; color: rgb(64 64 64); background: rgb(245 245 245);
+}
+.dark .mdxr-move:not(:disabled):hover {
+  color: rgb(212 212 212); background: rgb(38 38 38);
+}
+.mdxr-move:not(:disabled):active { transform: scale(0.85); }
+.mdxr-move:focus-visible {
+  outline: 2px solid rgb(14 165 233); outline-offset: 1px; opacity: 1;
+}
+.mdxr-move:disabled { opacity: 0.2; cursor: default; }
+@media print {
+  .mdxr-card-moves, .mdxr-board-tools, .mdxr-grip { display: none; }
+}
+/* <Comments>: a hover "+" on every code/diff row opens the comment form
+ * under that line. The button sits in the code block's left bleed band
+ * (.mdxr-cline — its .line child keeps the -1rem band bleed) or over the
+ * diff row's line-number gutter (.mdxr-drow); invisible until the row is
+ * hovered or the button takes keyboard focus. */
+.mdxr-cline, .mdxr-drow { position: relative; }
+.mdxr-add {
+  position: absolute; top: 0; bottom: 0; z-index: 1;
+  display: flex; align-items: center; justify-content: center;
+  width: 1rem; border: 0; padding: 0; background: transparent;
+  color: rgb(163 163 163); cursor: pointer; opacity: 0;
+  transition: opacity 0.12s ease, color 0.12s ease;
+}
+.mdxr-cline > .mdxr-add { left: -1rem; }
+.mdxr-drow > .mdxr-add { left: 0.1rem; }
+.mdxr-cline:hover > .mdxr-add, .mdxr-drow:hover > .mdxr-add,
+.mdxr-add:focus-visible { opacity: 1; }
+.mdxr-add:hover { color: rgb(2 132 199); }
+.dark .mdxr-add { color: rgb(115 115 115); }
+.dark .mdxr-add:hover { color: rgb(56 189 248); }
+@media print {
+  .mdxr-add, .mdxr-thread-tools, [data-comment-form] { display: none; }
+}
+@keyframes mdxr-pop {
+  0% { transform: scale(0.3); opacity: 0; }
+  70% { transform: scale(1.15); }
+  100% { transform: scale(1); opacity: 1; }
+}
+@keyframes mdxr-shake {
+  0%, 100% { transform: translateX(0); }
+  25% { transform: translateX(-2px); }
+  75% { transform: translateX(2px); }
+}
+/* shiki dual-theme: token spans carry --shiki-* variables, not colors.
+ * Scoping to .line descendants keeps spans that share a .shiki ancestor for
+ * layout (e.g. <Comments> thread strips) from losing their own colors to an
+ * undefined --shiki-* var. .mdxr-diff-hl marks the same kind of token span
+ * inside DiffView rows — it is not nested in a .shiki code element, so it
+ * joins the selectors here. */
+.shiki .line span, .mdxr-diff-hl {
+  color: var(--shiki-light);
+  font-style: var(--shiki-light-font-style, normal);
+  font-weight: var(--shiki-light-font-weight, normal);
+  text-decoration: var(--shiki-light-text-decoration, none);
+}
+@media (prefers-color-scheme: dark) {
+  .shiki .line span, .mdxr-diff-hl {
+    color: var(--shiki-dark);
+    font-style: var(--shiki-dark-font-style, normal);
+    font-weight: var(--shiki-dark-font-weight, normal);
+    text-decoration: var(--shiki-dark-text-decoration, none);
+  }
+}
+/* The .dark class (set by THEME_JS in documents, the toolbar in Storybook)
+ * wins over the media query so toggling it re-themes code blocks too. */
+.dark .shiki .line span, .dark .mdxr-diff-hl {
+  color: var(--shiki-dark);
+  font-style: var(--shiki-dark-font-style, normal);
+  font-weight: var(--shiki-dark-font-weight, normal);
+  text-decoration: var(--shiki-dark-text-decoration, none);
+}
+html:not(.dark) .shiki .line span, html:not(.dark) .mdxr-diff-hl {
+  color: var(--shiki-light);
+  font-style: var(--shiki-light-font-style, normal);
+  font-weight: var(--shiki-light-font-weight, normal);
+  text-decoration: var(--shiki-light-text-decoration, none);
+}
+/* Line-level features: fences carry has-* classes on <code> itself. The code
+ * is a column flex box so .line spans become block-level items (bands/numbers
+ * span the block width) while the raw "\n" text nodes shiki leaves between
+ * them collapse — whitespace-only anonymous flex items never render, so they
+ * can't double the line spacing under the pre's white-space: pre. The pre's
+ * p-4 (1rem) is mirrored here so highlight bands bleed to the block edge;
+ * min-height keeps empty .line spans from collapsing to zero. */
+.shiki { display: flex; flex-direction: column; }
+.shiki .line { display: block; min-height: 1lh; margin: 0 -1rem; padding: 0 1rem; }
+.shiki .line.highlighted { background: rgba(14, 165, 233, 0.1); }
+.dark .shiki .line.highlighted { background: rgba(14, 165, 233, 0.16); }
+.shiki .line.diff.add { background: rgba(16, 185, 129, 0.12); }
+.shiki .line.diff.remove { background: rgba(239, 68, 68, 0.1); }
+.dark .shiki .line.diff.add { background: rgba(16, 185, 129, 0.18); }
+.dark .shiki .line.diff.remove { background: rgba(239, 68, 68, 0.16); }
+.shiki .line.diff.add::before,
+.shiki .line.diff.remove::before {
+  display: inline-block; width: 1em; margin-right: 0.5em;
+  color: rgba(113, 113, 122, 0.8); user-select: none;
+}
+.shiki .line.diff.add::before { content: '+'; }
+.shiki .line.diff.remove::before { content: '−'; }
+.shiki .line.error { background: rgba(239, 68, 68, 0.12); }
+.shiki .line.warning { background: rgba(245, 158, 11, 0.14); }
+.dark .shiki .line.error { background: rgba(239, 68, 68, 0.2); }
+.dark .shiki .line.warning { background: rgba(245, 158, 11, 0.18); }
+.shiki.has-focused .line:not(.focused) { opacity: 0.4; }
+.shiki .line.focused { opacity: 1; }
+.shiki span.highlighted-word {
+  background: rgba(245, 158, 11, 0.18); border-radius: 0.25rem;
+  outline: 1px solid rgba(245, 158, 11, 0.35); padding: 0 0.1rem;
+}
+.shiki.has-line-numbers { counter-reset: mdxr-line; }
+.shiki.has-line-numbers .line::before {
+  counter-increment: mdxr-line; content: counter(mdxr-line);
+  display: inline-block; width: 1.8em; margin-right: 1em;
+  text-align: right; color: rgba(113, 113, 122, 0.6); user-select: none;
+}
+.shiki.has-line-numbers .line.diff.add::before,
+.shiki.has-line-numbers .line.diff.remove::before {
+  content: counter(mdxr-line); /* numbers win over the +/− gutter marker */
+}
+/* KaTeX display math gets a little breathing room. */
+.katex-display { margin: 1.25rem 0; }
+/* Smooth anchor jumps for the ToC and other in-page links. */
+html { scroll-behavior: smooth; }
+/* Native <details> used by Toc/Details/Tree/Json: drop the default marker,
+ * rotate the chevron on open. */
+.mdxr-toc > details > summary::-webkit-details-marker,
+.mdxr-details > summary::-webkit-details-marker,
+.mdxr-tree summary::-webkit-details-marker,
+.mdxr-json summary::-webkit-details-marker { display: none; }
+.mdxr-toc > details > summary::marker,
+.mdxr-details > summary::marker,
+.mdxr-tree summary::marker,
+.mdxr-json summary::marker { content: ""; }
+/* Json: the "N keys/items" badge only matters while the node is folded. */
+.mdxr-json details[open] > summary .mdxr-count { display: none; }
+.mdxr-chev { transition: transform 0.15s ease; }
+details[open] > summary .mdxr-chev { transform: rotate(90deg); }
+/* Smooth expand/collapse for the native <details> blocks (Details, Toc,
+ * Tree folders). Chromium animates block-size via ::details-content +
+ * interpolate-size; engines without the pseudo-element never match these
+ * rules and keep the instant toggle. */
+:root { interpolate-size: allow-keywords; }
+.mdxr-details::details-content,
+.mdxr-toc > details::details-content,
+.mdxr-tree details::details-content {
+  block-size: 0;
+  overflow-y: clip;
+  transition:
+    content-visibility 0.22s allow-discrete,
+    block-size 0.22s ease;
+}
+.mdxr-details[open]::details-content,
+.mdxr-toc > details[open]::details-content,
+.mdxr-tree details[open]::details-content {
+  block-size: auto;
+  block-size: calc-size(auto);
+}
+/* ToC outline: numbered top-level entries, guide-lined nested lists. */
+.mdxr-toc-body ul { list-style: none; margin: 0; padding: 0; }
+.mdxr-toc-body li > p { margin: 0; }
+.mdxr-toc-body a {
+  display: flex; align-items: baseline; gap: 0.55rem;
+  border-radius: 0.375rem; padding: 0.28rem 0.5rem;
+  font-size: 0.875rem; line-height: 1.45;
+  color: rgb(82 82 82); text-decoration: none;
+  transition: color 0.12s, background 0.12s;
+}
+.mdxr-toc-body a:hover { color: rgb(23 23 23); background: rgb(245 245 245); }
+.mdxr-toc-body a:active { background: rgb(229 229 229); }
+.dark .mdxr-toc-body a:active { background: rgb(64 64 64); }
+.dark .mdxr-toc-body a { color: rgb(163 163 163); }
+.dark .mdxr-toc-body a:hover { color: rgb(250 250 250); background: rgb(38 38 38); }
+.mdxr-toc-body > ul { counter-reset: mdxr-toc; }
+.mdxr-toc-body > ul > li { counter-increment: mdxr-toc; }
+.mdxr-toc-body > ul > li > p > a,
+.mdxr-toc-body > ul > li > a { font-weight: 500; color: rgb(64 64 64); }
+.dark .mdxr-toc-body > ul > li > p > a,
+.dark .mdxr-toc-body > ul > li > a { color: rgb(212 212 212); }
+.mdxr-toc-body > ul > li > p > a::before,
+.mdxr-toc-body > ul > li > a::before {
+  content: counter(mdxr-toc); min-width: 1em;
+  font-size: 0.72rem; font-weight: 400; font-variant-numeric: tabular-nums;
+  color: rgb(163 163 163);
+}
+.dark .mdxr-toc-body > ul > li > p > a::before,
+.dark .mdxr-toc-body > ul > li > a::before { color: rgb(115 115 115); }
+.mdxr-toc-body ul ul {
+  margin: 0.15rem 0 0.3rem 0.95rem; padding-left: 0.6rem;
+  border-left: 1px solid rgb(229 229 229);
+}
+.dark .mdxr-toc-body ul ul { border-color: rgb(64 64 64); }
+.mdxr-toc-body ul ul a { font-size: 0.8125rem; padding: 0.2rem 0.45rem; }
+/* Ask: native form controls stay interactive without hydration. The real
+ * inputs are visually hidden; state is styled through :checked/~ siblings. */
+.mdxr-choice {
+  transition: color 0.12s, background-color 0.12s, border-color 0.12s,
+    transform 0.1s ease;
+}
+.mdxr-choice:active { transform: scale(0.985); }
+.mdxr-choice:has(:checked) {
+  border-color: rgb(23 23 23); background: rgb(250 250 250);
+}
+.dark .mdxr-choice:has(:checked) {
+  border-color: rgb(163 163 163); background: rgb(38 38 38 / 0.35);
+}
+.mdxr-choice:has(:focus-visible),
+.mdxr-q:has(:focus-visible) input ~ .mdxr-switch {
+  outline: 2px solid rgb(14 165 233); outline-offset: 1px;
+}
+.mdxr-mark {
+  display: grid; place-items: center; flex-shrink: 0;
+  height: 1rem; width: 1rem; margin-top: 0.15rem;
+  border: 1px solid rgb(212 212 212); background: rgb(255 255 255);
+  color: transparent; transition: all 0.12s;
+}
+.mdxr-mark-box { border-radius: 0.25rem; }
+.mdxr-mark-radio { border-radius: 9999px; }
+.mdxr-mark-radio::after {
+  content: ""; width: 0.45rem; height: 0.45rem; border-radius: 9999px;
+  background: rgb(23 23 23); transform: scale(0);
+  transition: transform 0.12s;
+}
+.mdxr-choice input:checked ~ .mdxr-mark { border-color: rgb(23 23 23); }
+.mdxr-choice input:checked ~ .mdxr-mark-box {
+  background: rgb(23 23 23); color: rgb(255 255 255);
+}
+/* Checkbox glyph pops in instead of fading. */
+.mdxr-mark-box svg {
+  transform: scale(0.4);
+  transition: transform 0.16s cubic-bezier(0.34, 1.56, 0.64, 1);
+}
+.mdxr-choice input:checked ~ .mdxr-mark-box svg { transform: scale(1); }
+.mdxr-choice input:checked ~ .mdxr-mark-radio::after { transform: scale(1); }
+.dark .mdxr-mark { border-color: rgb(82 82 82); background: rgb(23 23 23); }
+.dark .mdxr-mark-radio::after { background: rgb(250 250 250); }
+.dark .mdxr-choice input:checked ~ .mdxr-mark { border-color: rgb(250 250 250); }
+.dark .mdxr-choice input:checked ~ .mdxr-mark-box {
+  background: rgb(250 250 250); color: rgb(23 23 23);
+}
+/* Toggle questions: a native checkbox styled as a switch. */
+.mdxr-switch {
+  position: relative; flex-shrink: 0;
+  height: 1.25rem; width: 2.25rem; border-radius: 9999px;
+  background: rgb(212 212 212); transition: background 0.15s;
+}
+.mdxr-switch::after {
+  content: ""; position: absolute; top: 0.125rem; left: 0.125rem;
+  height: 1rem; width: 1rem; border-radius: 9999px;
+  background: rgb(255 255 255); box-shadow: 0 1px 2px rgb(0 0 0 / 0.25);
+  transition: transform 0.15s, width 0.15s;
+}
+.mdxr-q input:checked ~ .mdxr-switch { background: rgb(23 23 23); }
+.mdxr-q input:checked ~ .mdxr-switch::after { transform: translateX(1rem); }
+/* Thumb stretches while the switch is held (iOS-style press feedback). */
+.mdxr-q:active .mdxr-switch::after { width: 1.25rem; }
+.mdxr-q:active input:checked ~ .mdxr-switch::after {
+  transform: translateX(0.875rem);
+}
+.dark .mdxr-switch { background: rgb(64 64 64); }
+.dark .mdxr-q input:checked ~ .mdxr-switch { background: rgb(245 245 245); }
+.dark .mdxr-q input:checked ~ .mdxr-switch::after { background: rgb(23 23 23); }
+/* Reduced motion: every animation/transition above becomes instant. */
+@media (prefers-reduced-motion: reduce) {
+  html { scroll-behavior: auto; }
+  .mdxr-add,
+  .mdxr-copy,
+  .mdxr-chev,
+  .mdxr-choice,
+  .mdxr-mark,
+  .mdxr-mark-box svg,
+  .mdxr-move,
+  .mdxr-switch,
+  .mdxr-switch::after,
+  .mdxr-theme,
+  .mdxr-toc-body a {
+    transition: none;
+  }
+  .mdxr-copy:active { transform: none; }
+  .mdxr-choice:active { transform: none; }
+  .mdxr-move:active { transform: none; }
+  .mdxr-theme:active { transform: none; }
+  .copied .mdxr-copy-done, .copy-failed { animation: none; }
+  .mdxr-theme .mdxr-theme-i { animation: none; }
+  .mdxr-details::details-content,
+  .mdxr-toc > details::details-content,
+  .mdxr-tree details::details-content { transition: none; }
+}
+`;
+//#endregion
+//#region src/tailwind.ts
+const require = module.createRequire(import.meta.url);
+const tailwindDir = path.dirname(require.resolve("tailwindcss/package.json"));
+/** Resolve `id` against the document dir then this package; false if absent. */
+const tryResolve = async (id, base) => {
+	try {
+		const resolved = require.resolve(id, { paths: [base, pkgRoot] });
+		await access(resolved);
+		return resolved;
+	} catch {
+		return false;
+	}
+};
+const resolveCss = async (id, base) => {
+	if (path.isAbsolute(id)) return id;
+	if (id === "tailwindcss") return path.join(tailwindDir, "index.css");
+	if (id.startsWith("tailwindcss/")) return path.join(tailwindDir, id.slice(12));
+	if (id.startsWith(".")) return path.resolve(base, id);
+	return await tryResolve(id, base);
+};
+/**
+* React escapes `&` `'` `"` `<` `>` inside rendered attributes. The scanner
+* must see the literal class text, so decode the entities React emits.
+*/
+const decodeEntities = (html) => html.replaceAll("&#x27;", "'").replaceAll("&quot;", "\"").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+/** `@import "<path>"` — quoted, with Windows separators normalized. */
+const importLine = (absPath) => `@import ${JSON.stringify(absPath.replaceAll("\\", "/"))};`;
+/**
+* Compile Tailwind v4 CSS covering every class candidate found in `sources`
+* (the rendered HTML, the .mdx source, bundled user components, our own dist).
+* `themePath` is imported by path — not inlined — so `@import "./x.css"`
+* inside a theme file resolves relative to the theme, and the file lands in
+* `dependencies` (which `mdxr serve` turns into watch targets).
+* Returns minified CSS ready to inline into the HTML document.
+*/
+const buildCss = async (sources, themePath) => {
+	const input = [
+		"@import \"./src/styles/globals.css\";",
+		"@plugin \"@tailwindcss/typography\";",
+		"@plugin \"@iconify/tailwind4\";",
+		BASE_CSS,
+		themePath === void 0 ? "" : importLine(themePath)
+	].join("\n");
+	const dependencies = /* @__PURE__ */ new Set();
+	const compiler = await compile$1(input, {
+		base: pkgRoot,
+		customCssResolver: resolveCss,
+		customJsResolver: tryResolve,
+		onDependency: (file) => {
+			dependencies.add(file);
+		}
+	});
+	const candidates = new Scanner({}).scanFiles(sources.map((s) => ({
+		content: s.extension === "html" ? decodeEntities(s.content) : s.content,
+		extension: s.extension
+	})));
+	const css = compiler.build(candidates);
+	return {
+		css: optimize(css, { minify: true }).code,
+		dependencies: [...dependencies]
+	};
+};
+//#endregion
+//#region src/render.ts
+/** Load a user components module (file or directory with an index file). */
+const loadComponents = async (componentsPath) => {
+	const entry = resolveModuleEntry(componentsPath);
+	const { module: mod, code } = await loadUserModule(entry);
+	return {
+		code,
+		components: mergeUserComponents(mod)
+	};
+};
+/** Components named by `config.componentsPath` — an empty map when unset. */
+const loadUserComponents = async (config) => config.componentsPath === void 0 ? { components: {} } : await loadComponents(config.componentsPath);
+/** Read all of our own shipped JS so Tailwind can scan built-in classes.
+*  Memoized: package sources don't change within a process (serve rebuilds
+*  would otherwise rescan dist+src on every keystroke). */
+let ownSourcesCache;
+const ownSources = async () => {
+	if (ownSourcesCache !== void 0) return ownSourcesCache;
+	const dirs = [path.join(pkgRoot, "dist"), path.join(pkgRoot, "src")];
+	const out = [];
+	const walk = async (d) => {
+		const ents = await readdir(d, { withFileTypes: true });
+		await Promise.all(ents.map(async (e) => {
+			const p = path.join(d, e.name);
+			if (e.isDirectory()) await walk(p);
+			else if (/\.(?:js|ts|tsx)$/u.test(e.name)) out.push({
+				content: await readFile(p, "utf-8"),
+				extension: e.name.split(".").pop() ?? ""
+			});
+		}));
+	};
+	await Promise.all(dirs.filter((d) => existsSync(d)).map(walk));
+	ownSourcesCache = out;
+	return out;
+};
+/**
+* Inline client bundle for hydration. No catalog component was read → nothing
+* in the document can hydrate, so the bundle is skipped entirely (pure
+* markdown docs stay lean). A bundle failure degrades to the (correct)
+* static output with a warning.
+*/
+const buildHydrateBundle = async (args) => {
+	if (!(args.hydrate ?? true) || args.usedComponents.length === 0) return;
+	try {
+		return await buildHydrateScript({
+			code: args.code,
+			componentsPath: args.config.componentsPath === void 0 ? void 0 : resolveModuleEntry(args.config.componentsPath),
+			fileLinks: args.fileLinks,
+			header: args.headerProps,
+			now: args.now,
+			usedComponents: args.usedComponents,
+			usedIcons: args.usedIcons
+		});
+	} catch (error) {
+		process.stderr.write(`mdxr: hydration bundle skipped: ${formatError(error)}\n`);
+		return;
+	}
+};
+/**
+* Frontmatter `status` is free-form YAML, not a JSX prop — normalize case
+* ("Doing" → "doing") and warn+drop anything outside STATUSES so a metadata
+* typo can't take down the whole document render.
+*/
+const headerStatus = (raw) => {
+	if (raw === void 0) return;
+	const norm = raw.trim().toLowerCase();
+	if (isStatus(norm)) return norm;
+	process.stderr.write(`mdxr: warning: frontmatter status "${raw}" is not one of ${STATUSES.join("|")} — the badge is skipped\n`);
+};
+/**
+* PlanHeader props from frontmatter — present only with a `title` and no
+* `<Plan>`-style `<article>` root in the body (that would render a second
+* header). Used for both the SSR header and the hydration payload.
+*/
+const frontmatterHeader = (fm, body) => {
+	const title = fm("title");
+	if (title === void 0 || title === "" || /<article/u.test(body)) return;
+	return {
+		date: fm("date"),
+		owner: fm("owner"),
+		status: headerStatus(fm("status")),
+		title,
+		updated: fm("updated"),
+		version: fm("version")
+	};
+};
+/** Render MDX source text to a standalone HTML document. */
+const render = async (source, opts = {}) => {
+	const dir = path.resolve(opts.dir ?? process.cwd());
+	const filePath = path.resolve(dir, opts.filePath ?? "document.mdx");
+	const config = await loadConfig(dir);
+	const user = await loadUserComponents(config);
+	const collisions = Object.keys(user.components).filter((k) => Object.hasOwn(builtinComponents, k));
+	for (const k of collisions) process.stderr.write(`mdxr: project component <${k}> overrides the built-in\n`);
+	const components = {
+		...builtinComponents,
+		...user.components
+	};
+	const { body, code, fileLinks, frontmatter, renderedAt, renderWithHeader, usedComponents, usedIcons } = await mdxToHtml(source, components, filePath, {
+		editor: config.editor,
+		hydrate: opts.hydrate
+	});
+	const fmStr = (key) => {
+		const val = frontmatter[key];
+		if (typeof val === "string") return val === "" ? void 0 : val;
+		if (val instanceof Date) return val.toISOString().slice(0, 10);
+		return typeof val === "number" ? String(val) : void 0;
+	};
+	const fmTitle = fmStr("title");
+	const h1Text = /<h1[^>]*>(?<text>[\s\S]*?)<\/h1>/u.exec(body)?.groups?.text.replaceAll(/<[^>]*>/gu, "").replaceAll("&#x27;", "'").replaceAll("&quot;", "\"").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&").trim();
+	const title = fmTitle ?? (nonEmpty(h1Text) ? h1Text : void 0) ?? "mdxr document";
+	const headerProps = frontmatterHeader(fmStr, body);
+	let docBody = body;
+	let docFileLinks = fileLinks;
+	let docIcons = usedIcons;
+	if (headerProps !== void 0) {
+		const pass = renderWithHeader(createElement(PlanHeader, headerProps));
+		docBody = pass.html;
+		docFileLinks = pass.fileLinks;
+		docIcons = pass.usedIcons;
+	}
+	const themeCss = config.themePath === void 0 ? void 0 : await readFile(config.themePath, "utf-8");
+	const sources = [
+		{
+			content: docBody,
+			extension: "html"
+		},
+		{
+			content: source,
+			extension: "mdx"
+		},
+		{
+			content: themeCss ?? "",
+			extension: "css"
+		},
+		...await ownSources(),
+		...user.code === void 0 ? [] : [{
+			content: user.code,
+			extension: "js"
+		}],
+		...config.componentsCode === void 0 ? [] : [{
+			content: config.componentsCode,
+			extension: "js"
+		}]
+	];
+	const { css, dependencies } = await buildCss(sources, config.themePath);
+	opts.onDependencies?.(dependencies);
+	const [js, hydrateJs] = await Promise.all([clientJs(), buildHydrateBundle({
+		code,
+		config,
+		fileLinks: docFileLinks,
+		headerProps,
+		hydrate: opts.hydrate,
+		now: renderedAt,
+		usedComponents,
+		usedIcons: docIcons
+	})]);
+	return htmlDocument({
+		body: docBody,
+		clientJs: js,
+		css,
+		hydrateJs,
+		liveReload: opts.liveReload,
+		needsKatex: /class="[^"]*katex/u.test(docBody),
+		needsMermaid: /class="[^"]*mermaid/u.test(docBody),
+		title
+	});
+};
+/** Read `mdxPath` and render it to a standalone HTML document. */
+const renderFile = async (mdxPath, opts = {}) => {
+	const abs = path.resolve(mdxPath);
+	const source = await readFile(abs, "utf-8");
+	return await render(source, {
+		...opts,
+		dir: path.dirname(abs),
+		filePath: abs
+	});
+};
+//#endregion
+//#region src/serve.ts
+const errorPage = (err) => `<!doctype html><meta charset="utf-8"><body style="font-family:monospace;background:#1c1917;color:#fca5a5;padding:2rem"><h1>mdxr render error</h1><pre>${formatError(err).replaceAll("&", "&amp;").replaceAll("<", "&lt;")}</pre></body>`;
+/** Dependency/build output dirs — never worth a watch fd. */
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+	".git",
+	".mdxr-cache",
+	"dist",
+	"node_modules",
+	"storybook-static"
+]);
+/**
+* The set of directories being watched. `fs.watch` recursive mode exists only
+* on darwin/win32 — elsewhere `arm` puts one non-recursive watcher per
+* directory, which also survives atomic saves (rename-over kills a watch
+* aimed at the file itself).
+*/
+const createWatchSet = () => {
+	const watchers = [];
+	const armed = /* @__PURE__ */ new Set();
+	const track = (w, dir) => {
+		watchers.push(w);
+		if (dir !== void 0) {
+			armed.add(dir);
+			w.on("close", () => {
+				armed.delete(dir);
+			});
+		}
+		w.on("error", () => {
+			w.close();
+		});
+	};
+	/** One watcher on `dir` itself (no descent). */
+	const armFlat = (dir, onEvent) => {
+		if (armed.has(dir) || SKIP_DIRS.has(path.basename(dir))) return;
+		try {
+			track(fs.watch(dir, onEvent), dir);
+		} catch {}
+	};
+	/**
+	* Recursive fallback: a watcher on `dir` plus every directory under it.
+	* The `armed` check guards only the watcher install — the descent still
+	* runs on an already-armed root, so directories created mid-session get
+	* picked up on the next rebuild (armDeps re-arms the tree for this).
+	*/
+	const arm = (dir, onEvent) => {
+		if (SKIP_DIRS.has(path.basename(dir))) return;
+		if (!armed.has(dir)) try {
+			track(fs.watch(dir, onEvent), dir);
+		} catch {}
+		let ents;
+		try {
+			ents = fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const e of ents) if (e.isDirectory()) arm(path.join(dir, e.name), onEvent);
+	};
+	return {
+		arm,
+		armFlat,
+		close() {
+			for (const w of watchers) w.close();
+		},
+		get size() {
+			return watchers.length;
+		},
+		track
+	};
+};
+const servePreview = async (target, port) => {
+	let html = "";
+	const clients = /* @__PURE__ */ new Set();
+	const server = http.createServer((req, res) => {
+		if (req.url === "/__mdxr_events") {
+			res.writeHead(200, {
+				"cache-control": "no-cache",
+				connection: "keep-alive",
+				"content-type": "text/event-stream"
+			});
+			res.write("retry: 1000\n\n");
+			clients.add(res);
+			req.on("close", () => {
+				clients.delete(res);
+			});
+			res.on("error", () => {
+				clients.delete(res);
+			});
+			return;
+		}
+		res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+		res.end(html);
+	});
+	const watch = createWatchSet();
+	let recursiveWatch = false;
+	let timer;
+	/**
+	* Dependency files (theme CSS, its nested imports) may live outside the
+	* watched document directory. Inside the watch dir the root watcher covers
+	* them; outside, a flat watcher on the file's own directory suffices —
+	* and avoids descending into a potentially huge ancestor tree. Also
+	* re-arms the tree so directories created mid-session are picked up.
+	*/
+	const armDeps = (onEvent) => {
+		if (!recursiveWatch) watch.arm(target.watchDir, onEvent);
+		for (const dep of target.deps?.() ?? []) {
+			const dir = path.dirname(dep);
+			if (dir === target.watchDir || dir.startsWith(`${target.watchDir}${path.sep}`) || dir.split(path.sep).includes("node_modules")) continue;
+			watch.armFlat(dir, onEvent);
+		}
+	};
+	const rebuild = async (onEvent) => {
+		try {
+			html = await target.renderDoc();
+		} catch (error) {
+			html = errorPage(error);
+		}
+		armDeps(onEvent);
+	};
+	let reloading = Promise.resolve();
+	const reload = (onEvent) => {
+		const prev = reloading;
+		reloading = (async () => {
+			await prev;
+			try {
+				await rebuild(onEvent);
+				for (const c of clients) try {
+					c.write("event: reload\ndata: {}\n\n");
+				} catch {
+					clients.delete(c);
+				}
+			} catch {}
+		})();
+	};
+	const notify = () => {
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			reload(notify);
+		}, 80);
+	};
+	try {
+		watch.track(fs.watch(target.watchDir, { recursive: true }, notify));
+		recursiveWatch = true;
+	} catch {
+		watch.arm(target.watchDir, notify);
+	}
+	if (watch.size === 0 && target.watchFile !== void 0) try {
+		watch.track(fs.watch(target.watchFile, notify));
+	} catch {}
+	server.on("close", () => {
+		clearTimeout(timer);
+		watch.close();
+	});
+	await rebuild(notify);
+	server.listen(port, "127.0.0.1");
+	try {
+		await once(server, "listening");
+	} catch (error) {
+		server.close();
+		throw error;
+	}
+	const address = server.address();
+	const boundPort = typeof address === "object" && address !== null ? address.port : port;
+	console.log(`mdxr: serving ${target.label} at http://localhost:${boundPort}`);
+	console.log("mdxr: watching for changes (Ctrl+C to stop)");
+	return server;
+};
+/**
+* Wraps a render fn with dependency tracking: `deps` reads the paths the
+* last render reported via `onDependencies` (theme CSS + its imports), so
+* `armDeps` can watch files outside the document's own directory.
+*/
+const trackDeps = (renderDoc) => {
+	let deps = [];
+	return {
+		deps: () => deps,
+		renderDoc: async () => {
+			const collected = [];
+			const doc = await renderDoc((d) => {
+				collected.push(...d);
+			});
+			deps = collected;
+			return doc;
+		}
+	};
+};
+/** Serve an .mdx file, rebuilding + live-reloading on changes in its directory. */
+const serve = async (mdxPath, port) => {
+	const abs = path.resolve(mdxPath);
+	return await servePreview({
+		label: mdxPath,
+		...trackDeps(async (onDeps) => await renderFile(abs, {
+			liveReload: true,
+			onDependencies: onDeps
+		})),
+		watchDir: path.dirname(abs),
+		watchFile: abs
+	}, port);
+};
+/** Serve MDX source passed directly (e.g. piped via stdin). */
+const serveSource = async (source, port, opts = {}) => {
+	const dir = path.resolve(opts.dir ?? process.cwd());
+	return await servePreview({
+		label: opts.filePath ?? "stdin",
+		...trackDeps(async (onDeps) => await render(source, {
+			dir,
+			filePath: opts.filePath,
+			liveReload: true,
+			onDependencies: onDeps
+		})),
+		watchDir: dir
+	}, port);
+};
+//#endregion
+//#region src/cli.ts
+const readStdin = async () => {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf-8");
+};
+const requireStdinSource = () => {
+	if (process.stdin.isTTY) throw new Error("no input: pass an .mdx file or pipe MDX source via stdin");
+};
+const fail = (err, json) => {
+	if (json) console.log(JSON.stringify({
+		error: formatError(err),
+		ok: false
+	}));
+	else console.error(`mdxr: error: ${formatError(err)}`);
+	process.exit(1);
+};
+const cli = cac("mdxr");
+cli.command("render [file]", "Render an .mdx document to a standalone HTML file").option("-o, --out <path>", "Output path (default: <file>.html; stdout for stdin input or '-')").option("--format <format>", "Error output: text | json").option("--no-hydrate", "Emit static HTML without the client hydration bundle").action(async (file, opts) => {
+	const json = opts.format === "json";
+	try {
+		parseErrorFormat(opts.format);
+		const fromStdin = file === void 0 || file === "-";
+		if (fromStdin) requireStdinSource();
+		const html = fromStdin ? await render(await readStdin(), {
+			dir: process.cwd(),
+			filePath: "<stdin>",
+			hydrate: opts.hydrate
+		}) : await renderFile(file, { hydrate: opts.hydrate });
+		const out = opts.out === "-" ? void 0 : opts.out ?? (fromStdin ? void 0 : `${file.replace(/\.(?:mdx|md)$/u, "")}.html`);
+		if (out === void 0) {
+			process.stdout.on("error", (err) => {
+				if (err.code === "EPIPE") process.exit(0);
+				throw err;
+			});
+			process.stdout.write(html);
+			return;
+		}
+		await writeFile(path.resolve(out), html);
+		if (json) console.log(JSON.stringify({
+			ok: true,
+			out
+		}));
+		else console.log(`mdxr: wrote ${out}`);
+	} catch (error) {
+		fail(error, json);
+	}
+});
+cli.command("serve [file]", "Preview a document in the browser with live reload").option("-p, --port <port>", "Port", { default: 3737 }).action(async (file, opts) => {
+	try {
+		const port = Number(opts.port);
+		if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error(`invalid --port: ${opts.port}`);
+		if (file === void 0 || file === "-") {
+			requireStdinSource();
+			await serveSource(await readStdin(), port, {
+				dir: process.cwd(),
+				filePath: "<stdin>"
+			});
+			return;
+		}
+		await serve(file, port);
+	} catch (error) {
+		fail(error, false);
+	}
+});
+cli.command("catalog", "List available components (built-in + project-defined)").option("--json", "Print machine-readable JSON").option("--dir <dir>", "Project directory to read mdxr.config.ts from").action(async (opts) => {
+	try {
+		const dir = path.resolve(opts.dir ?? process.cwd());
+		const config = await loadConfig(dir);
+		const user = await loadUserComponents(config);
+		const entries = catalogEntries(user.components);
+		if (opts.json === true) console.log(JSON.stringify({
+			builtins: Object.keys(builtinComponents),
+			components: entries,
+			conventions: CONVENTIONS
+		}, null, 2));
+		else console.log(formatCatalog(entries));
+	} catch (error) {
+		fail(error, false);
+	}
+});
+cli.command("init", "Install the mdxr agent skill into this project").option("--tool <tool>", "agents | claude | devin | all", { default: "agents" }).option("--global", "Install into your home directory instead of the project").option("--force", "Overwrite an existing skill").action(async (opts) => {
+	try {
+		const paths = await installSkill(opts);
+		for (const p of paths) console.log(`mdxr: installed skill → ${p}`);
+	} catch (error) {
+		fail(error, false);
+	}
+});
+cli.help();
+cli.parse();
+//#endregion
+export {};