@docubook/flame 2.0.0-beta.1 → 2.0.0-beta.3

package/.docu/lib/html.shared-FwgbE1WG.js

@@ -0,0 +1,2696 @@
+import { a as DOCS_DIR, c as PROJECT_ROOT, d as loadDocuConfig, f as resolveProjectFile, l as STYLES_DIR, o as FRAMEWORK_ROOT, s as LIB_DIR, t as ASSETS_DIR, u as cleanOldBundles } from "./paths-Bl2cdp9E.js";
+import { a as isExternalUrl, h as normalizeImporterPath, n as docsHtmlHref, o as scanMdxFiles, r as formatDate2, t as cn } from "./utils-DA17MyQG.js";
+import { builtinModules, createRequire } from "node:module";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { mkdir, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { build } from "vite";
+import { generateThemeCss, presetRegistry, resolveTheme } from "@docubook/themes-colors";
+import { createHash } from "node:crypto";
+import React, { createContext, useCallback, useContext, useEffect, useRef, useState } from "react";
+import { z } from "zod";
+import { MDXRemote, createDefaultRehypePlugins, createDefaultRemarkPlugins, extractFrontmatter, extractFrontmatterWithContent, extractTocsFromRawMdx, serialize } from "@docubook/core";
+import { createMdxComponents } from "@docubook/markdown";
+import * as LucideIcons from "lucide-react";
+import { ArrowUpIcon, ArrowUpRight, ChevronDown, ChevronLeft, ChevronRight, ListIcon, SquarePen } from "lucide-react";
+import { Breadcrumb, BreadcrumbItem, BreadcrumbList, BreadcrumbPage } from "@docubook/ui-react/breadcrumbs";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { PaginationDocs } from "@docubook/ui-react/pagination";
+//#region .docu/node/plugin-loader.ts
+var NPM_PACKAGE_RE = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+/**
+* Resolve a plugin specifier to an absolute path or npm package name.
+*
+* Resolution rules:
+* 1. Relative path (starts with `.`) → resolve from project root, guard traversal
+* 2. Absolute path (starts with `/`) → guard traversal
+* 3. Anything else → validate as npm package name, then pass to Bun's import
+*
+* Path traversal protection:
+* - All file-system paths (relative & absolute) must resolve within PROJECT_ROOT.
+* - This prevents `../../sensitive-file` or `/etc/passwd` from being imported.
+*/
+/** @internal Exported for testing only. */
+function resolveSpecifier(specifier) {
+	let resolved;
+	if (specifier.startsWith(".")) resolved = resolve(PROJECT_ROOT, specifier);
+	else if (specifier.startsWith("/")) resolved = specifier;
+	else {
+		if (!NPM_PACKAGE_RE.test(specifier)) throw new Error(`[plugin-loader] Invalid plugin specifier "${specifier}": must be a valid npm package name, relative path, or absolute path`);
+		return specifier;
+	}
+	const root = PROJECT_ROOT.endsWith("/") ? PROJECT_ROOT : PROJECT_ROOT + "/";
+	if (!resolved.startsWith(root)) throw new Error(`[plugin-loader] Path traversal blocked: "${specifier}" resolves outside project root`);
+	return resolved;
+}
+/**
+* Load and instantiate all plugins from a config entries array.
+*
+* @param entries - Array of plugin entries from `docu.json`.
+*   Each entry is either:
+*   - a `string` (plugin specifier, no options)
+*   - a `[string, object]` tuple (plugin specifier + factory options)
+* @returns Array of resolved `DocuBookPlugin` instances.
+*
+* @throws If a plugin specifier cannot be imported.
+* @throws If a plugin's default export lacks a `name` property.
+*
+* @example
+* const plugins = await loadPlugins([
+*   "@docubook/plugin-sitemap",
+*   ["@docubook/plugin-analytics", { id: "G-XXXXXXX" }],
+*   "./plugins/local-reading-time",
+* ]);
+*/
+async function loadPlugins(entries = []) {
+	const plugins = [];
+	for (const entry of entries) {
+		const [specifier, options] = Array.isArray(entry) ? entry : [entry, void 0];
+		const resolved = resolveSpecifier(specifier);
+		let mod;
+		try {
+			mod = await import(resolved);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			throw new Error(`[plugin-loader] Failed to import plugin "${specifier}": ${message}`, { cause: err });
+		}
+		const exported = mod.default;
+		let plugin;
+		if (typeof exported === "function") try {
+			plugin = exported(options);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			throw new Error(`[plugin-loader] Plugin factory "${specifier}" threw during initialization: ${message}`, { cause: err });
+		}
+		else if (exported && typeof exported === "object") plugin = exported;
+		else throw new Error(`[plugin-loader] Plugin "${specifier}" must export a default function or object. Got: ${typeof exported}`);
+		if (!plugin.name || typeof plugin.name !== "string") throw new Error(`[plugin-loader] Plugin "${specifier}" must have a valid 'name' property (string). Got: ${typeof plugin.name}`);
+		if (typeof plugin.setup !== "function") throw new Error(`[plugin-loader] Plugin "${specifier}" (name: "${plugin.name}") must have a 'setup(build)' function.`);
+		plugins.push(plugin);
+	}
+	return plugins;
+}
+//#endregion
+//#region .docu/node/plugin-builder.ts
+var BuildPluginBuilder = class {
+	config;
+	_handleRequest = [];
+	_injectBody = [];
+	_injectHead = [];
+	_onEnd = [];
+	_onLoad = [];
+	_onStart = [];
+	_rehypePlugins = [];
+	_remarkPlugins = [];
+	_transformFrontmatter = [];
+	_transformHtml = [];
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Collect and deduplicate all `<body>` injection snippets from registered plugins.
+	* Each callback is executed in registration order; plugin errors are wrapped
+	* with a descriptive message.
+	*
+	* @param context - Current page context passed to each injectBody callback.
+	* @returns Deduplicated array of HTML strings to inject before `</body>`.
+	* @throws Error if any injectBody callback throws — wraps original error as cause.
+	*/
+	collectBody(context) {
+		const items = [];
+		for (const cb of this._injectBody) try {
+			const result = cb(context);
+			if (result) this.collectItems(items, result, "injectBody");
+		} catch (err) {
+			throw new Error(`[plugin] injectBody callback failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+		}
+		return [...new Set(items)];
+	}
+	/**
+	* Collect and deduplicate all `<head>` injection snippets from registered plugins.
+	* Each callback is executed in registration order; plugin errors are wrapped
+	* with a descriptive message.
+	*
+	* @param context - Current page context passed to each injectHead callback.
+	* @returns Deduplicated array of HTML strings to inject before `</head>`.
+	* @throws Error if any injectHead callback throws — wraps original error as cause.
+	*/
+	collectHead(context) {
+		const items = [];
+		for (const cb of this._injectHead) try {
+			const result = cb(context);
+			if (result) this.collectItems(items, result, "injectHead");
+		} catch (err) {
+			throw new Error(`[plugin] injectHead callback failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+		}
+		return [...new Set(items)];
+	}
+	/**
+	* Collect all rehype plugin arrays from registered rehypePlugins callbacks.
+	* Results from all plugins are flattened into a single array.
+	*
+	* @returns Flattened array of rehype plugin instances applied after default set.
+	* @throws Error if any rehypePlugins callback throws — wraps original error as cause.
+	*/
+	collectRehypePlugins() {
+		const plugins = [];
+		for (const cb of this._rehypePlugins) try {
+			plugins.push(...cb());
+		} catch (err) {
+			throw new Error(`[plugin] rehypePlugins callback failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+		}
+		return plugins;
+	}
+	/**
+	* Collect all remark plugin arrays from registered remarkPlugins callbacks.
+	* Results from all plugins are flattened into a single array.
+	*
+	* @returns Flattened array of remark plugin instances applied after default set.
+	* @throws Error if any remarkPlugins callback throws — wraps original error as cause.
+	*/
+	collectRemarkPlugins() {
+		const plugins = [];
+		for (const cb of this._remarkPlugins) try {
+			plugins.push(...cb());
+		} catch (err) {
+			throw new Error(`[plugin] remarkPlugins callback failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+		}
+		return plugins;
+	}
+	/**
+	* Register a callback to intercept incoming requests during development.
+	* The **first** callback to return a `Response` short-circuits all subsequent handlers.
+	* Errors inside callbacks are caught and logged — execution continues to next handler.
+	*
+	* @param callback - Receives the Request and dev server context. Return Response or void.
+	*
+	* @example
+	* build.handleRequest((req, ctx) => {
+	*   if (new URL(req.url).pathname === "/api/status") {
+	*     return new Response(JSON.stringify({ ok: true }), {
+	*       headers: { "Content-Type": "application/json" },
+	*     });
+	*   }
+	* });
+	*/
+	handleRequest(callback) {
+		this._handleRequest.push(callback);
+	}
+	/**
+	* Register a callback that returns HTML strings to inject before `</body>`.
+	* Results from all plugins are merged, deduplicated, and served via `collectBody()`.
+	*
+	* @param callback - Returns a single HTML string or an array. Called once per page.
+	*
+	* @example
+	* build.injectBody(() => `<div id="chat-widget"></div>`);
+	*/
+	injectBody(callback) {
+		this._injectBody.push(callback);
+	}
+	/**
+	* Register a callback that returns HTML strings to inject inside `<head>`.
+	* Results from all plugins are merged, deduplicated, and served via `collectHead()`.
+	*
+	* @param callback - Returns a single HTML string or an array. Called once per page.
+	*
+	* @example
+	* build.injectHead(() => `<script async src="https://cdn.example.com/analytics.js"><\/script>`);
+	*/
+	injectHead(callback) {
+		this._injectHead.push(callback);
+	}
+	/**
+	* Register a callback to run once after all pages are built.
+	* Receives the resolved config and aggregated page metadata.
+	* Errors thrown by the callback propagate to the caller via `runOnEnd()`.
+	*
+	* @param callback - Receives config and page metadata array. May return a Promise.
+	*
+	* @example
+	* build.onEnd(async (config, pages) => {
+	*   const xml = generateSitemap(pages, config.meta.baseURL);
+	*   const out = ".docu/dist/sitemap.xml";
+	*   // Bun.write on Bun for speed, writeFile on Node/Deno
+	*   await (typeof Bun !== "undefined"
+	*     ? Bun.write(out, xml)
+	*     : writeFile(out, xml));
+	* });
+	*/
+	onEnd(callback) {
+		this._onEnd.push(callback);
+	}
+	/**
+	* Register a callback to transform raw file content before MDX compilation.
+	* Filtered by regex against the file's relative path — only the **first** matching
+	* handler's result is used.
+	* Errors thrown by the callback propagate to the caller via `runOnLoad()`.
+	*
+	* @param args.filter - RegExp matched against the file's relative path.
+	* @param args.namespace - Optional namespace prefix (reserved for future use).
+	* @param callback - Receives file path and raw content. Return new contents or void.
+	*
+	* @example
+	* build.onLoad({ filter: /\.md$/ }, ({ path, content }) => {
+	*   return { contents: `<!-- preprocessed -->\n${content}`, loader: "mdx" };
+	* });
+	*/
+	onLoad(args, callback) {
+		this._onLoad.push({
+			...args,
+			fn: callback
+		});
+	}
+	/**
+	* Register a callback to run once before the build starts.
+	* Receives the resolved DocuConfig for validation or resource initialization.
+	* Errors thrown by the callback propagate to the caller via `runOnStart()`.
+	*
+	* @param callback - Receives the resolved config. May return a Promise.
+	*
+	* @example
+	* build.onStart((config) => {
+	*   if (!config.meta.baseURL) throw new Error("baseURL required");
+	* });
+	*/
+	onStart(callback) {
+		this._onStart.push(callback);
+	}
+	/**
+	* Register additional rehype (HTML) plugins for the MDX compilation pipeline.
+	* Results from all plugins are merged and applied **after** the default set.
+	*
+	* @param callback - Returns an array of rehype plugins.
+	*
+	* @example
+	* build.rehypePlugins(() => [require("rehype-autolink-headings")]);
+	*/
+	rehypePlugins(callback) {
+		this._rehypePlugins.push(callback);
+	}
+	/**
+	* Register additional remark (Markdown) plugins for the MDX compilation pipeline.
+	* Results from all plugins are merged and applied **after** the default set.
+	*
+	* @param callback - Returns an array of remark plugins.
+	*
+	* @example
+	* build.remarkPlugins(() => [require("remark-custom-heading-id")]);
+	*/
+	remarkPlugins(callback) {
+		this._remarkPlugins.push(callback);
+	}
+	/**
+	* Execute all registered handleRequest callbacks sequentially.
+	* Stops and returns the **first** `Response` returned by any callback.
+	* Errors inside individual callbacks are caught and logged — execution
+	* continues to the next callback without throwing.
+	*
+	* @param req - The incoming HTTP Request.
+	* @param context - Dev server context (port, hostname).
+	* @returns A Response if a callback intercepted the request, or null if none did.
+	*/
+	async runHandleRequest(req, context) {
+		for (let i = 0; i < this._handleRequest.length; i++) try {
+			const result = await this._handleRequest[i](req, context);
+			if (result instanceof Response) return result;
+		} catch (err) {
+			console.error(`[plugin] handleRequest callback #${i + 1} error: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		return null;
+	}
+	/**
+	* Execute all registered onEnd callbacks sequentially with the resolved
+	* config and aggregated page metadata.
+	* Errors inside individual callbacks are caught and logged — execution
+	* continues to the next callback without throwing.
+	*
+	* @param pages - Array of metadata for every built page.
+	*/
+	async runOnEnd(pages) {
+		for (let i = 0; i < this._onEnd.length; i++) try {
+			await this._onEnd[i](this.config, pages);
+		} catch (err) {
+			console.error(`[plugin] onEnd callback #${i + 1} error: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	/**
+	* Execute registered onLoad handlers in registration order against a file.
+	* Only the **first** handler whose `filter` regex matches the path and returns
+	* a result is applied. If a matching handler throws, the error is logged and
+	* subsequent handlers are tried.
+	*
+	* @param path - Relative path of the file being loaded.
+	* @param content - Raw file content.
+	* @returns Transformed content if a matching handler returned it, or null.
+	*/
+	async runOnLoad(path, content) {
+		for (const handler of this._onLoad) if (handler.filter.test(path)) try {
+			const result = await handler.fn({
+				path,
+				content
+			});
+			if (result) return result;
+		} catch (err) {
+			console.error(`[plugin] onLoad handler for filter ${handler.filter} error: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		return null;
+	}
+	/**
+	* Execute all registered onStart callbacks sequentially.
+	* Each callback receives the resolved DocuConfig.
+	* Errors inside individual callbacks are caught and logged — execution
+	* continues to the next callback without throwing.
+	*/
+	async runOnStart() {
+		for (let i = 0; i < this._onStart.length; i++) try {
+			await this._onStart[i](this.config);
+		} catch (err) {
+			console.error(`[plugin] onStart callback #${i + 1} error: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	/**
+	* Execute the transformFrontmatter chain in waterfall pattern.
+	* Each callback receives the **previous** callback's return value (or the
+	* original frontmatter for the first). Callbacks that return `undefined` or
+	* `null` pass the current value through unchanged.
+	* Callbacks that return a non-object (string, number, array) are skipped
+	* with a console warning — only plain objects are accepted.
+	* Errors inside individual callbacks are caught and logged — the current
+	* frontmatter passes through unchanged for that step.
+	*
+	* @param frontmatter - Initial frontmatter object parsed from MDX.
+	* @param context - Page context with slug, filePath, and raw content.
+	* @returns The final transformed frontmatter object.
+	*/
+	async runTransformFrontmatterChain(frontmatter, context) {
+		let result = frontmatter;
+		for (let i = 0; i < this._transformFrontmatter.length; i++) try {
+			const next = await this._transformFrontmatter[i](result, context);
+			if (next !== void 0 && next !== null) {
+				if (typeof next === "object" && !Array.isArray(next)) result = next;
+				else console.warn(`[plugin] transformFrontmatter callback #${i + 1} returned invalid type (expected a plain object), skipping`);
+			}
+		} catch (err) {
+			console.error(`[plugin] transformFrontmatter callback #${i + 1} error: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		return result;
+	}
+	/**
+	* Execute the transformHtml chain in pipeline pattern.
+	* Each callback receives the **previous** callback's return value (or the
+	* original HTML for the first). Every callback **must** return a string.
+	* Errors inside individual callbacks are caught and logged — the current
+	* HTML passes through unchanged for that step.
+	*
+	* @param html - The initial HTML string.
+	* @param context - Full page context (slug, filePath, frontmatter, content, config).
+	* @returns The final transformed HTML string.
+	*/
+	async runTransformHtmlChain(html, context) {
+		let result = html;
+		for (let i = 0; i < this._transformHtml.length; i++) try {
+			result = await this._transformHtml[i](result, context);
+		} catch (err) {
+			console.error(`[plugin] transformHtml callback #${i + 1} error: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		return result;
+	}
+	/**
+	* Register a callback to mutate frontmatter before MDX compilation.
+	* Callbacks are chained in a waterfall: the return value of one is passed
+	* as input to the next. Return `undefined` to pass through unchanged.
+	*
+	* **Note:** Only plain objects are accepted as return values. Returning
+	* a string, number, or array will be silently skipped with a warning.
+	* Plugin authors should validate their return values before returning.
+	*
+	* @param callback - Receives frontmatter object and page context.
+	*
+	* @example
+	* build.transformFrontmatter((fm, ctx) => {
+	*   const wordCount = ctx.content!.split(/\s+/).length;
+	*   return { ...fm, readingTime: `${Math.ceil(wordCount / 200)} min read` };
+	* });
+	*/
+	transformFrontmatter(callback) {
+		this._transformFrontmatter.push(callback);
+	}
+	/**
+	* Register a callback to transform the final HTML string per page.
+	* This is the **last** hook before the HTML is written to disk.
+	* Callbacks are chained in a pipeline: each receives the previous callback's output.
+	*
+	* @param callback - Receives HTML string and full page context. Must return HTML.
+	*
+	* @example
+	* build.transformHtml((html, ctx) => {
+	*   return html.replace(/https?:\/\/old-domain\.com\//g, "/");
+	* });
+	*/
+	transformHtml(callback) {
+		this._transformHtml.push(callback);
+	}
+	/**
+	* Collect items from a callback result, filtering only valid strings.
+	* Non-string items and unexpected types are logged as warnings.
+	*/
+	collectItems(items, result, hookName) {
+		if (Array.isArray(result)) for (const item of result) if (typeof item === "string") items.push(item);
+		else console.warn(`[plugin] ${hookName} callback returned non-string item (got ${typeof item}), skipping`);
+		else if (typeof result === "string") items.push(result);
+		else console.warn(`[plugin] ${hookName} callback returned unexpected type (got ${typeof result}), expected string or string[], skipping`);
+	}
+};
+/** Toolchain fingerprint: Bun version on Bun, Deno version on Deno, Node elsewhere. */
+function runtimeStamp() {
+	const g = globalThis;
+	const bun = g.Bun;
+	if (typeof bun?.version === "string" && bun.version.length > 0) return `bun-${bun.version}`;
+	const deno = g.Deno;
+	if (typeof deno?.version?.deno === "string" && deno.version.deno.length > 0) return `deno-${deno.version.deno}`;
+	const proc = g.process;
+	if (typeof proc?.version === "string" && proc.version.length > 0) return `node-${proc.version}`;
+	return "node-unknown";
+}
+/**
+* True when a CSS file can change Tailwind v4 output.
+* v4 is CSS-first: `@theme`, `@source`, `@plugin`, `@custom-variant`,
+* `@utility`, `@config`, `@apply`/`@variant`, and `@import "tailwindcss"`
+* all live in CSS. Plain CSS without these cannot affect the CLI output,
+* so it is excluded to avoid false cache busts. Broad match deliberate:
+* false positive busts safe, false negative serves stale CSS.
+*/
+function isTailwindRelevantCss(content) {
+	return content.includes("@theme") || content.includes("@source") || content.includes("@plugin") || content.includes("@custom-variant") || content.includes("@utility") || content.includes("@config") || content.includes("@apply") || content.includes("@variant") || content.includes("@layer") || content.includes("tailwindcss");
+}
+var IMPORT_RE = /@import\s+(?:url\()?["']([^"']+)["']/g;
+var MAX_IMPORT_DEPTH = 10;
+/** Resolve `./` + `../` imports only — bare specifiers are version-pinned deps. */
+function resolveRelativeImport(spec, fromDir) {
+	if (!spec.startsWith(".")) return void 0;
+	const clean = spec.split("?")[0].split("#")[0];
+	if (clean.length === 0) return void 0;
+	return join(fromDir, clean);
+}
+/**
+* Read a CSS file plus transitively imported relative files.
+* Non-relevant files contribute "" themselves, but their imports are still
+* followed (nested file may carry `@theme`). `visited` breaks import cycles.
+* Missing/unreadable files resolve to "" — never throws.
+*/
+function readCssWithImports(path, visited, depth = 0) {
+	if (depth > MAX_IMPORT_DEPTH || visited.has(path)) return "";
+	visited.add(path);
+	let content = "";
+	try {
+		if (!existsSync(path)) return "";
+		content = readFileSync(path, "utf-8");
+	} catch {
+		return "";
+	}
+	let out = isTailwindRelevantCss(content) ? content : "";
+	try {
+		const dir = join(path, "..");
+		for (const m of content.matchAll(IMPORT_RE)) {
+			const resolved = resolveRelativeImport(m[1] ?? "", dir);
+			if (resolved) out += readCssWithImports(resolved, visited, depth + 1);
+		}
+	} catch {}
+	return out;
+}
+function scanCssDir(dir, visited) {
+	let out = "";
+	try {
+		const entries = readdirSync(dir, { withFileTypes: true });
+		for (const e of entries) {
+			const full = join(dir, e.name);
+			if (e.isDirectory()) {
+				if (e.name === "assets" || e.name.startsWith(".") || e.name === "node_modules") continue;
+				out += scanCssDir(full, visited);
+			} else if (e.name.endsWith(".css")) out += readCssWithImports(full, visited);
+		}
+	} catch {}
+	return out;
+}
+function scanRootCss(root, visited) {
+	let out = "";
+	try {
+		const entries = readdirSync(root, { withFileTypes: true });
+		for (const e of entries) if (e.isFile() && e.name.endsWith(".css")) out += readCssWithImports(join(root, e.name), visited);
+	} catch {}
+	return out;
+}
+/** Hash @theme/@source/@plugin-bearing CSS in project docs/ + root *.css. */
+function tailwindCssThemeInputs(root) {
+	const visited = /* @__PURE__ */ new Set();
+	return scanCssDir(join(root, "docs"), visited) + scanRootCss(root, visited);
+}
+var TAILWIND_CONFIG_FILES = [
+	"tailwind.config.ts",
+	"tailwind.config.js",
+	"tailwind.config.mjs",
+	"tailwind.config.cjs",
+	"tailwind.config.mts",
+	"tailwind.config.cts",
+	"postcss.config.js",
+	"postcss.config.mjs",
+	"postcss.config.cjs"
+];
+/**
+* JS config still affects v4 when referenced via `@config`
+* (plus PostCSS pipeline config). Content hashed when present.
+*/
+function tailwindJsConfigInputs(root) {
+	let out = "";
+	for (const name of TAILWIND_CONFIG_FILES) try {
+		const p = join(root, name);
+		if (existsSync(p)) out += readFileSync(p, "utf-8") + "\0";
+	} catch {}
+	return out;
+}
+function readInstalledVersion(pkg, roots) {
+	for (const root of roots) try {
+		const p = join(root, "node_modules", ...pkg.split("/"), "package.json");
+		if (existsSync(p)) {
+			const parsed = JSON.parse(readFileSync(p, "utf-8"));
+			if (typeof parsed.version === "string" && parsed.version.length > 0) return parsed.version;
+		}
+	} catch {}
+	return "";
+}
+/** Pin resolved CSS-affecting deps into the key (installed version wins). */
+function tailwindVersionPins(root) {
+	const names = [
+		"tailwindcss",
+		"@tailwindcss/cli",
+		"@tailwindcss/typography",
+		"daisyui"
+	];
+	let extra = "";
+	const roots = [root, FRAMEWORK_ROOT];
+	for (const name of names) {
+		const installed = readInstalledVersion(name, roots);
+		if (installed) extra += `${name}@${installed}\0`;
+	}
+	try {
+		const pkgPath = join(root, "package.json");
+		if (existsSync(pkgPath)) {
+			const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+			for (const name of names) {
+				const range = pkg.dependencies?.[name] ?? pkg.devDependencies?.[name] ?? "";
+				if (range) extra += `${name}:${range}\0`;
+			}
+		}
+	} catch {}
+	return extra;
+}
+/**
+* Extra Tailwind inputs beyond globals.css + theme.
+* v4 is CSS-first: user overrides live in `@theme`/`@source`/`@plugin`
+* blocks inside CSS files under the project root (e.g. docs slash star dot css),
+* plus JS config referenced via `@config` and installed plugin versions.
+* Missing files resolve to "" — never throws.
+*/
+function tailwindExtraInputs(root = resolveProjectFile()) {
+	return tailwindCssThemeInputs(root) + "\0" + tailwindJsConfigInputs(root) + tailwindVersionPins(root);
+}
+/**
+* Shared Tailwind cache key: globals.css + theme + tailwind config +
+* toolchain version. Used by both hydrate.ts (Bun) and hydrate.node.ts
+* (Vite) so the two runtimes agree on filenames. Segments joined with NUL
+* so `("ab","c")` and `("a","bc")` hash differently.
+*/
+function computeTailwindCacheKey(globals, themeSuffix, projectRoot = resolveProjectFile()) {
+	const h = createHash("sha256");
+	h.update(globals);
+	h.update("\0");
+	h.update(themeSuffix);
+	h.update("\0");
+	h.update(tailwindExtraInputs(projectRoot));
+	h.update("\0");
+	h.update(runtimeStamp());
+	h.update("\0");
+	h.update(`v3`);
+	return h.digest("hex").slice(0, 16);
+}
+/** Read globals.css content ("" when missing). Shared by both hydrators. */
+function readGlobalsCss() {
+	const globalsPath = join(STYLES_DIR, "globals.css");
+	return existsSync(globalsPath) ? readFileSync(globalsPath, "utf-8") : "";
+}
+/**
+* Atomic file write: tmp + rename so a crash mid-write never leaves a
+* half-written cache/CSS behind. Tmp name includes pid so parallel
+* builds (`bun run --parallel`) do not clobber each other.
+*/
+async function atomicWriteFile(writeFile, rename, unlink, target, data) {
+	const proc = globalThis.process;
+	const tmp = `${target}.tmp-${typeof proc?.pid === "number" ? proc.pid : Math.floor(Math.random() * 1e9)}-${Date.now()}`;
+	try {
+		await writeFile(tmp, data);
+		await rename(tmp, target);
+	} catch (err) {
+		try {
+			await unlink(tmp);
+		} catch {}
+		throw err;
+	}
+}
+/** Wire memory-pressure hook once: OS low-memory → drop parsed page maps. */
+var memoryPressureHooked = false;
+function hookMemoryPressure(clear) {
+	if (memoryPressureHooked) return;
+	memoryPressureHooked = true;
+	try {
+		globalThis.process?.on?.("memoryPressure", () => {
+			try {
+				clear();
+			} catch {}
+		});
+	} catch {}
+}
+/**
+* Hash of compiled MDX module sources (sorted keys + content).
+* Used to skip the JS bundle rebuild when no page content changed.
+*/
+function hashMdxSources(mdxSources) {
+	const h = createHash("sha256");
+	const slugs = Object.keys(mdxSources).sort();
+	h.update(`v3:${runtimeStamp()}:`);
+	for (const slug of slugs) {
+		h.update(slug);
+		h.update("\0");
+		h.update(mdxSources[slug]);
+		h.update("\0");
+	}
+	return h.digest("hex").slice(0, 16);
+}
+//#endregion
+//#region .docu/node/fs-scanner.ts
+function toTitleCase$1(str) {
+	return str.replace(/-/g, " ").replace(/_/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+function isDocFile(filename) {
+	const ext = extname(filename).toLowerCase();
+	return [".mdx", ".md"].includes(ext);
+}
+function normalizePath(path) {
+	return path.split(sep).join("/");
+}
+/**
+* Recursively scan a directory and return file tree
+*
+* @param dirPath - Absolute path to scan
+* @param docsRoot - Root docs folder for relative path calculation
+*/
+function scanDir(dirPath, docsRoot) {
+	const nodes = [];
+	let entries;
+	try {
+		entries = readdirSync(dirPath).sort();
+	} catch (err) {
+		if (err.code !== "ENOENT") throw err;
+		return nodes;
+	}
+	for (const entry of entries) {
+		if (entry.startsWith(".") || entry === "assets") continue;
+		const absPath = join(dirPath, entry);
+		try {
+			const stat = statSync(absPath);
+			if (stat.isDirectory()) {
+				const children = scanDir(absPath, docsRoot);
+				if (children.length > 0) nodes.push({
+					name: entry,
+					relPath: normalizePath(relative(docsRoot, absPath)),
+					absPath,
+					isDirectory: true,
+					children
+				});
+			} else if (stat.isFile() && isDocFile(entry)) nodes.push({
+				name: entry,
+				relPath: normalizePath(relative(docsRoot, absPath).replace(/\.(mdx|md)$/, "")),
+				absPath,
+				isDirectory: false
+			});
+		} catch (err) {
+			if (err.code !== "ENOENT") throw err;
+			continue;
+		}
+	}
+	return nodes;
+}
+function fileNodesToRoutes(nodes, parentHref = "") {
+	const routes = [];
+	for (const node of nodes) if (!node.isDirectory) {
+		const baseName = node.name.replace(/\.(mdx|md)$/, "");
+		if (/^(index|readme)$/i.test(baseName)) continue;
+		const href = `/${node.relPath.split("/").pop()}`;
+		routes.push({
+			title: toTitleCase$1(baseName),
+			href
+		});
+	} else {
+		const dirTitle = toTitleCase$1(node.name);
+		const dirHref = `/${node.relPath.split("/").pop()}`;
+		const children = fileNodesToRoutes(node.children || [], dirHref);
+		if (children.length === 0) continue;
+		if ((node.children || []).some((c) => !c.isDirectory && /^(index|readme)\.(mdx|md)$/i.test(c.name))) routes.push({
+			title: dirTitle,
+			href: dirHref,
+			...parentHref === "" && { context: {
+				title: dirTitle,
+				icon: "CircleHelp",
+				description: dirTitle
+			} },
+			items: children
+		});
+		else routes.push({
+			title: dirTitle,
+			href: dirHref,
+			noLink: true,
+			...parentHref === "" && { context: {
+				title: dirTitle,
+				icon: "CircleHelp",
+				description: dirTitle
+			} },
+			items: children
+		});
+	}
+	return routes;
+}
+/**
+* Scan docs folder and convert to DocuRoute[]
+*
+* @param docsPath - Path to docs folder (default: "./docs")
+*/
+function scanDocsFolder(docsPath = "./docs") {
+	const absDocsPath = join(process.cwd(), docsPath);
+	return fileNodesToRoutes(scanDir(absDocsPath, absDocsPath));
+}
+/**
+* Resolve routes:
+* 1. If docu.json has routes, use them (manual priority)
+* 2. Else, scan docs folder (auto-detect)
+*
+* @param docuJsonRoutes - Routes from docu.json (optional)
+*/
+function resolveRoutes(docuJsonRoutes) {
+	if (docuJsonRoutes && docuJsonRoutes.length > 0) return docuJsonRoutes;
+	return scanDocsFolder();
+}
+//#endregion
+//#region .docu/node/hydrate.ts
+var themeRegistry = presetRegistry;
+/**
+* Read the effective theme config with this priority:
+* 1. FLAME_THEME env var (CLI --theme flag)
+* 2. docu.json theme.colors field
+*/
+function getThemeConfig() {
+	if (process.env.FLAME_THEME) return process.env.FLAME_THEME;
+	return loadDocuConfig().themes?.colors;
+}
+/**
+* Append theme CSS to compiled Tailwind output based on theme config.
+*/
+function buildThemeCss(baseCss, themeConfig) {
+	try {
+		const resolved = resolveTheme(themeConfig, themeRegistry);
+		return baseCss + "\n" + generateThemeCss(resolved);
+	} catch (err) {
+		console.warn(`[flame] Failed to resolve theme CSS: ${err instanceof Error ? err.message : String(err)}`);
+		return baseCss;
+	}
+}
+/**
+* Compute inline theme CSS for FOUC prevention.
+* Returns undefined if no theme is configured or on error.
+*/
+function computeInlineThemeCss() {
+	try {
+		const themeColors = getThemeConfig();
+		if (themeColors) {
+			const resolved = resolveTheme(themeColors, themeRegistry);
+			return generateThemeCss(resolved);
+		}
+	} catch (err) {
+		console.warn(`[flame] Failed to compute inline theme CSS: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+//#endregion
+//#region .docu/node/hydrate.node.ts
+/**
+* Client bundle builder for Node/Deno runtimes.
+*
+* Uses Vite with Rolldown plugins to produce a browser-ready client
+* bundle (JS + CSS) from the same components Bun.build handles natively.
+* Theme helpers (getThemeConfig, buildThemeCss, computeInlineThemeCss)
+* are re-exported from `hydrate.ts` — that module's `buildClientBundle`
+* is Bun-only and unused here.
+*/
+/** Extract Lucide icon names from user docu.json configuration. */
+function extractConfigIcons(config) {
+	const icons = [];
+	const pushIf = (s) => {
+		if (s) icons.push(s);
+	};
+	config.home?.hero?.actions?.forEach((a) => pushIf(a.icon));
+	config.home?.features?.forEach((f) => pushIf(f.icon));
+	(function walk(routes) {
+		for (const r of routes) {
+			pushIf(r.context?.icon);
+			if (r.items) walk(r.items);
+		}
+	})(config.routes ?? []);
+	return [...new Set(icons.filter((n) => /^[A-Z]/.test(n)))];
+}
+var execFileAsync = promisify(execFile);
+/** Resolve the @tailwindcss/cli binary path from the installed package. */
+function resolveTailwindBin() {
+	const require = createRequire(import.meta.url);
+	const pkgPath = require.resolve("@tailwindcss/cli/package.json");
+	const pkg = require(pkgPath);
+	const binRel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin.tailwindcss;
+	return join(dirname(pkgPath), binRel);
+}
+/** Compute a cache key from globals.css + theme + config + toolchain. */
+function tailwindCacheKey() {
+	const globalsContent = readGlobalsCss();
+	let themeSuffix = "";
+	try {
+		const themeColors = getThemeConfig();
+		if (themeColors) themeSuffix = JSON.stringify(themeColors);
+	} catch {}
+	return computeTailwindCacheKey(globalsContent, themeSuffix);
+}
+/**
+* Build Tailwind CSS with content-based caching.
+* If a CSS file for the current input hash already exists, skip the subprocess.
+* Returns the filename (e.g. "client-abc123.css") and CSS content.
+*/
+async function buildTailwindCss(key) {
+	const cachedFile = `client-${key}.css`;
+	const cachedPath = join(ASSETS_DIR, cachedFile);
+	if (existsSync(cachedPath)) return {
+		file: cachedFile,
+		content: readFileSync(cachedPath, "utf-8")
+	};
+	const tmpCss = join(ASSETS_DIR, `_tmp-${key}.css`);
+	const bin = resolveTailwindBin();
+	const twArgs = [
+		"-i",
+		join(STYLES_DIR, "globals.css"),
+		"-o",
+		tmpCss,
+		"--minify"
+	];
+	const args = "Deno" in globalThis ? [
+		"run",
+		"-A",
+		bin,
+		...twArgs
+	] : [bin, ...twArgs];
+	try {
+		await execFileAsync(process.execPath, args, { maxBuffer: 16777216 });
+	} catch (err) {
+		const stderr = err.stderr ?? String(err);
+		throw new Error(`Tailwind CSS build failed:\n${stderr}`, { cause: err });
+	}
+	let cssContent = await readFile(tmpCss, "utf-8");
+	await unlink(tmpCss).catch(() => {});
+	try {
+		const themeColors = getThemeConfig();
+		if (themeColors) cssContent = buildThemeCss(cssContent, themeColors);
+	} catch (err) {
+		console.warn(`[flame] Failed to resolve theme config, falling back to globals.css only: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	const cssFile = `client-${key}.css`;
+	const outPath = join(ASSETS_DIR, cssFile);
+	if (!existsSync(outPath)) await atomicWriteFile(writeFile, rename, unlink, outPath, cssContent);
+	return {
+		file: cssFile,
+		content: cssContent
+	};
+}
+var NODE_BUILTINS_RE = new RegExp(`^(node:.*|${builtinModules.map((m) => m.replace(/\//g, "\\/")).join("|")})$`);
+var lucideRealEntry;
+/** Resolve the real lucide-react entry path once (cached). */
+function getLucideRealEntry() {
+	if (!lucideRealEntry) lucideRealEntry = createRequire(import.meta.url).resolve("lucide-react");
+	return lucideRealEntry;
+}
+var LUCIDE_IMPORT_RE = /import\s*\{([^}]+)\}\s*from\s*["']lucide-react["']/g;
+var LUCIDE_ICON_RE = /^[A-Z]/;
+/** Walk a directory scanning JS/TS/TSX files for `lucide-react` named imports. */
+function scanDirLucideIcons(dir, set) {
+	if (!existsSync(dir)) return;
+	try {
+		const entries = readdirSync(dir, { withFileTypes: true });
+		for (const e of entries) {
+			const full = join(dir, e.name);
+			if (e.isDirectory()) {
+				if (e.name !== "node_modules") scanDirLucideIcons(full, set);
+			} else if (/\.(js|ts|tsx)$/.test(e.name)) {
+				const content = readFileSync(full, "utf-8");
+				for (const m of content.matchAll(LUCIDE_IMPORT_RE)) for (const s of m[1].split(",")) {
+					const name = s.trim().split(/\s+as\s+/)[0].trim();
+					if (LUCIDE_ICON_RE.test(name)) set.add(name);
+				}
+			}
+		}
+	} catch (err) {
+		console.warn(`[flame] Failed to scan lucide icons: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+/** Collect every lucide icon name imported across flame sources and deps. */
+function collectAllLucideIcons() {
+	const icons = /* @__PURE__ */ new Set();
+	scanDirLucideIcons(join(FRAMEWORK_ROOT, ".docu/components"), icons);
+	scanDirLucideIcons(join(FRAMEWORK_ROOT, ".docu/pages"), icons);
+	const depDirs = [
+		join(FRAMEWORK_ROOT, "..", "mdx-content", "dist"),
+		join(FRAMEWORK_ROOT, "..", "ui-react", "dist"),
+		join(FRAMEWORK_ROOT, "..", "core", "dist"),
+		join(FRAMEWORK_ROOT, "..", "themes-colors", "dist")
+	];
+	for (const d of depDirs) scanDirLucideIcons(resolve(d), icons);
+	return [...icons];
+}
+/** Build the client JS bundle and Tailwind CSS. */
+async function buildClientBundle(mdxSources = {}) {
+	await mkdir(ASSETS_DIR, { recursive: true });
+	const twKey = tailwindCacheKey();
+	await cleanOldBundles(/* @__PURE__ */ new Set([`client-${twKey}.css`]));
+	const nodeEnv = process.env.NODE_ENV || "development";
+	const entryPath = join(LIB_DIR, "client.ts");
+	const bundle = await build({
+		configFile: false,
+		publicDir: false,
+		define: { "process.env.NODE_ENV": JSON.stringify(nodeEnv) },
+		plugins: [
+			{
+				name: "node-builtin-stub",
+				resolveId(id) {
+					if (NODE_BUILTINS_RE.test(id)) return `\0node-stub:${id}`;
+					return null;
+				},
+				load(id) {
+					if (!id.startsWith("\0node-stub:")) return null;
+					return "export default {}; export {};";
+				}
+			},
+			{
+				name: "lucide-optimize",
+				resolveId(id, importer) {
+					if (id !== "lucide-react") return null;
+					if (importer) {
+						if (normalizeImporterPath(importer).includes("/markdown/dist/")) return null;
+					}
+					return "\0lucide-virt";
+				},
+				load(id) {
+					if (id !== "\0lucide-virt") return null;
+					const scanned = collectAllLucideIcons();
+					const configured = extractConfigIcons(loadDocuConfig());
+					return `export { ${[.../* @__PURE__ */ new Set([...scanned, ...configured])].join(", ")} } from ${JSON.stringify(getLucideRealEntry())};`;
+				}
+			},
+			{
+				name: "docu-config",
+				resolveId(id) {
+					if (!/client-routes$/.test(id)) return null;
+					return "\0client-routes";
+				},
+				load(id) {
+					if (id !== "\0client-routes") return null;
+					const config = loadDocuConfig();
+					const resolved = {
+						...config,
+						routes: resolveRoutes(config.routes)
+					};
+					return [
+						`const docuConfig = ${JSON.stringify(resolved)};`,
+						`export const routes = docuConfig.routes || [];`,
+						`export const config = docuConfig;`
+					].join("\n");
+				}
+			},
+			{
+				name: "mdx-hydrate",
+				resolveId(id) {
+					if (/mdx-manifest$/.test(id)) return "\0mdx-manifest";
+					if (id.startsWith("mdx-module:")) return `\0${id}`;
+					return null;
+				},
+				load(id) {
+					if (id === "\0mdx-manifest") {
+						const slugs = Object.keys(mdxSources).sort();
+						return `${slugs.map((slug, i) => {
+							const key = slug.replace(/["\\]/g, "");
+							return `import * as _mdx${i} from ${JSON.stringify(`mdx-module:${key}`)};`;
+						}).join("\n")}\nexport const mdxModules = { ${slugs.map((slug, i) => `${JSON.stringify(slug)}: _mdx${i}`).join(", ")} };\n`;
+					}
+					if (!id.startsWith("\0mdx-module:")) return null;
+					const slug = id.slice(12);
+					const contents = mdxSources[slug];
+					if (contents == null) throw new Error(`unknown mdx module: ${slug}`);
+					return contents;
+				}
+			}
+		],
+		build: {
+			outDir: ASSETS_DIR,
+			emptyOutDir: false,
+			sourcemap: true,
+			minify: nodeEnv === "production",
+			target: "es2020",
+			rollupOptions: {
+				input: entryPath,
+				output: {
+					format: "es",
+					entryFileNames: "client-[hash].js",
+					chunkFileNames: "chunks/[name]-[hash].js",
+					assetFileNames: "assets/[name]-[hash][extname]"
+				}
+			}
+		}
+	});
+	const outputs = Array.isArray(bundle) ? bundle : [bundle];
+	let jsFile;
+	for (const item of outputs) {
+		if (!("output" in item)) continue;
+		for (const output of item.output) if (output.type === "chunk" && output.isEntry && output.facadeModuleId && resolve(output.facadeModuleId) === entryPath) {
+			jsFile = basename(output.fileName);
+			break;
+		}
+		if (jsFile) break;
+	}
+	if (!jsFile) throw new Error("Client bundle produced no output files");
+	const { file: cssFile } = await buildTailwindCss(twKey);
+	await writeFile(join(ASSETS_DIR, "manifest.json"), JSON.stringify({
+		js: jsFile,
+		css: cssFile
+	}));
+	return {
+		js: jsFile,
+		css: cssFile
+	};
+}
+//#endregion
+//#region .docu/node/git.ts
+/**
+* Runtime-neutral git helpers — same behavior as the git functions in
+* `utils.ts` (Bun-only, protected) but spawning via `node:child_process`,
+* which works on Bun, Node.js, and Deno. `mdx.ts` imports from here.
+*/
+function runGit(args) {
+	return new Promise((resolve, reject) => {
+		execFile("git", args, { maxBuffer: 16777216 }, (err, stdout) => {
+			if (err) reject(err);
+			else resolve(stdout);
+		});
+	});
+}
+function sanitizePath(filePath) {
+	const cleanPath = filePath.replace(/^\//, "");
+	if (!cleanPath || !/^[a-zA-Z0-9\-_/.\s]+$/.test(cleanPath) || /(^|\/)\.\.($|\/)/.test(cleanPath)) return null;
+	return cleanPath;
+}
+/** Get git last modified date for a file */
+async function getGitLastModified(filePath) {
+	const cleanPath = sanitizePath(filePath);
+	if (!cleanPath) return null;
+	try {
+		return (await runGit([
+			"log",
+			"-1",
+			"--format=%cI",
+			"--",
+			cleanPath
+		])).trim() || null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Fallback to filesystem mtime when git is unavailable (shallow clone, no .git, etc.).
+* Returns ISO 8601 date string or null.
+*/
+async function getFilesystemMtime(filePath) {
+	try {
+		return (await stat(filePath)).mtime.toISOString();
+	} catch {
+		return null;
+	}
+}
+/** Batch git last modified dates for multiple files in a single spawn */
+async function getGitLastModifiedBatch(filePaths) {
+	const result = /* @__PURE__ */ new Map();
+	if (filePaths.length === 0) return result;
+	const safePaths = [];
+	for (const fp of filePaths) {
+		const cleanPath = sanitizePath(fp);
+		if (!cleanPath) {
+			console.warn(`[git] getGitLastModifiedBatch: skipping invalid path "${fp}"`);
+			continue;
+		}
+		safePaths.push(cleanPath);
+	}
+	if (safePaths.length === 0) return result;
+	try {
+		const text = await runGit([
+			"log",
+			"--format=%cI",
+			"--name-only",
+			"--diff-filter=ACMR",
+			...safePaths
+		]);
+		let currentDate = "";
+		for (const line of text.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			if (/^\d{4}-\d{2}-\d{2}T/.test(trimmed)) currentDate = trimmed;
+			else if (currentDate && !result.has(trimmed)) result.set(trimmed, currentDate);
+		}
+	} catch (err) {
+		console.error("Failed to get git last modified batch for", filePaths, err);
+	}
+	return result;
+}
+//#endregion
+//#region .docu/node/mdx.ts
+/**
+* Return the value with `.html` appended, or null if the value should be left
+* unchanged.  Rules:
+*  - Must be a string
+*  - Must start with /docs/  (the /docs root index needs no suffix)
+*  - Must not be an external URL, contain a fragment, or already end in .html
+*/
+function appendHtml(value) {
+	if (typeof value !== "string") return null;
+	if (/^https?:\/\//.test(value)) return null;
+	if (!value.startsWith("/docs/")) return null;
+	if (value.includes("#")) return null;
+	if (value.endsWith(".html")) return null;
+	return `${value}.html`;
+}
+/**
+* Rehype plugin: append `.html` to internal `/docs/` hrefs on HTML `<a>` nodes.
+*
+* This covers standard markdown links: `[text](/docs/page)` → `<a href="…">`.
+* It runs in the HAST (HTML AST) phase, where `<a>` elements are real nodes.
+*
+* Skips: external URLs, anchor-only links, paths that already end in `.html`,
+* and the `/docs` root index (no trailing slash segment).
+*/
+function rehypeDocsHtmlLinks() {
+	return (tree) => {
+		function walk(node) {
+			if (node.type === "element" && node.tagName === "a") {
+				const fixed = appendHtml(node.properties?.href);
+				if (fixed) node.properties.href = fixed;
+			}
+			if (node.children) for (const child of node.children) walk(child);
+		}
+		walk(tree);
+		return tree;
+	};
+}
+/**
+* Remark plugin: append `.html` to internal `/docs/` hrefs on MDX JSX nodes.
+*
+* MDX JSX elements (`<Card href="…">`, `<LinkCard href="…">`, etc.) live in
+* the MDAST as `mdxJsxFlowElement` / `mdxJsxTextElement` nodes.  They are
+* compiled directly to JavaScript by the MDX compiler *before* rehype runs,
+* so a rehype plugin can never see them as `<a>` elements.  This remark plugin
+* intercepts them at the MDAST phase where their `attributes` array is still
+* accessible and mutable.
+*
+* Skips: same rules as `appendHtml` (external URLs, anchors, already `.html`).
+*/
+function remarkMdxJsxDocsHtmlLinks() {
+	return (tree) => {
+		function walk(node) {
+			if ((node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") && node.attributes) {
+				for (const attr of node.attributes) if (attr.type === "mdxJsxAttribute" && attr.name === "href") {
+					const fixed = appendHtml(attr.value);
+					if (fixed) attr.value = fixed;
+				}
+			}
+			if (node.children) for (const child of node.children) walk(child);
+		}
+		walk(tree);
+		return tree;
+	};
+}
+z.object({
+	title: z.coerce.string().optional(),
+	description: z.coerce.string().optional(),
+	image: z.coerce.string().optional(),
+	date: z.coerce.string().optional()
+}).passthrough();
+/**
+* Read a string field from frontmatter after the plugin transform chain
+* (which widens the type to `Record<string, unknown>`). Returns "" when
+* missing or not a string.
+*/
+function frontmatterField(frontmatter, key) {
+	return typeof frontmatter[key] === "string" ? frontmatter[key] : "";
+}
+/**
+* Compile MDX/MD content into a React element and compiled source.
+*
+* @param rawMdx - Raw MDX/MD file content
+* @param filePath - Relative file path for git date lookup
+* @param gitDates - Optional pre-fetched git last-modified map
+* @param remarkPlugins - Additional remark plugins (merged after defaults, optional)
+* @param rehypePlugins - Additional rehype plugins (merged after defaults, optional)
+* @param frontmatterSchema - Custom schema overriding the default contract
+*/
+/**
+* Shared compile core used by `compileMdx` (SSR) and `compileMdxModule`
+* (static hydration). Strips frontmatter, merges the doc plugin chain
+* (defaults + .html link fixes + user plugins) and runs `serialize()`.
+*/
+async function serializeWithDocPlugins(rawMdx, opts = {}, pre) {
+	const { strippedContent, frontmatter } = pre ?? (opts.frontmatterSchema ? extractFrontmatterWithContent(rawMdx, opts.frontmatterSchema) : extractFrontmatterWithContent(rawMdx));
+	const defaultRemark = createDefaultRemarkPlugins();
+	const defaultRehype = createDefaultRehypePlugins();
+	const finalRemark = [
+		...defaultRemark,
+		remarkMdxJsxDocsHtmlLinks,
+		...opts.remarkPlugins ?? []
+	];
+	const finalRehype = [
+		...defaultRehype,
+		rehypeDocsHtmlLinks,
+		...opts.rehypePlugins ?? []
+	];
+	return serialize(strippedContent, {
+		outputFormat: opts.outputFormat,
+		format: "md",
+		mdxOptions: {
+			rehypePlugins: finalRehype,
+			remarkPlugins: finalRemark
+		}
+	}).then((serialized) => ({
+		...serialized,
+		frontmatter,
+		strippedContent
+	}));
+}
+/**
+* Compile MDX/MD content into a React element and compiled source.
+*
+* @param rawMdx - Raw MDX/MD file content
+* @param filePath - Relative file path for git date lookup
+* @param gitDates - Optional pre-fetched git last-modified map
+* @param remarkPlugins - Additional remark plugins (merged after defaults, optional)
+* @param rehypePlugins - Additional rehype plugins (merged after defaults, optional)
+* @param frontmatterSchema - Custom schema overriding the default contract
+*/
+async function compileMdx(rawMdx, filePath, gitDates, remarkPlugins, rehypePlugins, frontmatterSchema, pre) {
+	const tocs = extractTocsFromRawMdx(rawMdx);
+	const frontmatter = pre?.frontmatter ?? (frontmatterSchema ? extractFrontmatterWithContent(rawMdx, frontmatterSchema).frontmatter : extractFrontmatterWithContent(rawMdx).frontmatter);
+	const serialized = await serializeWithDocPlugins(rawMdx, {
+		remarkPlugins,
+		rehypePlugins,
+		frontmatterSchema
+	}, pre);
+	const components = createMdxComponents();
+	const content = React.createElement(MDXRemote, {
+		compiledSource: serialized.compiledSource,
+		scope: {},
+		frontmatter: {},
+		components
+	});
+	const date = frontmatter.date || gitDates?.get(filePath) || await getGitLastModified(filePath) || await getFilesystemMtime(filePath) || void 0;
+	return {
+		content,
+		compiledSource: serialized.compiledSource,
+		frontmatter: {
+			...frontmatter,
+			date
+		},
+		tocs
+	};
+}
+/**
+* Compile MDX to a real ESM module source (program format) for static
+* client-side hydration — the browser imports and executes it via the bundler
+* instead of `new Function(compiledSource)`. Uses the same plugin chain as
+* `compileMdx` so the hydrated tree matches the SSR output.
+*/
+/**
+* Frontmatter records collected once during compilation — pagination title /
+* description and other metadata consumers read from here instead of
+* re-reading + re-parsing files (parse-once contract: the frontmatter is
+* already parsed by `serializeWithDocPlugins`).
+*/
+var pageFrontmatter = /* @__PURE__ */ new Map();
+/** Register a page's frontmatter, keyed by its href. */
+function registerPageFrontmatter(href, frontmatter) {
+	pageFrontmatter.set(href, frontmatter);
+}
+/** Look up a page's frontmatter (undefined when not yet compiled). */
+function getPageFrontmatter(href) {
+	return pageFrontmatter.get(href);
+}
+/**
+* Frontmatter-stripped content from the prePass — lets the SSR compile
+* phase skip its own `extractFrontmatterWithContent` (parse-once across
+* both compile phases).
+*/
+var pageStripped = /* @__PURE__ */ new Map();
+function registerPageStripped(href, stripped) {
+	pageStripped.set(href, stripped);
+}
+function getPageStripped(href) {
+	return pageStripped.get(href);
+}
+/**
+* Original (pre-transform) file content, cached during the prePass so the
+* page loop does not re-read the file from disk — one read per file.
+*/
+var pageContent = /* @__PURE__ */ new Map();
+function registerPageContent(href, raw) {
+	pageContent.set(href, raw);
+}
+function getPageContent(href) {
+	return pageContent.get(href);
+}
+/** Drop derived page maps under OS memory pressure (Bun 1.4 `memoryPressure`). */
+function clearDerivedPageCaches() {
+	pageContent.clear();
+	pageStripped.clear();
+	pageFrontmatter.clear();
+}
+async function compileMdxModule(rawMdx, remarkPlugins, rehypePlugins, href) {
+	const serialized = await serializeWithDocPlugins(rawMdx, {
+		outputFormat: "program",
+		remarkPlugins,
+		rehypePlugins
+	});
+	if (href) {
+		registerPageFrontmatter(href, serialized.frontmatter);
+		registerPageStripped(href, serialized.strippedContent);
+	}
+	return serialized.compiledSource;
+}
+//#endregion
+//#region .docu/node/search-indexer.ts
+/**
+* Search Index Generator
+*
+* Scans MDX files at build-time and produces a search-index.json
+* with hierarchy-based records (similar to Algolia DocSearch crawler).
+*
+* Hierarchy levels:
+*   lvl0 = section (parent route title)
+*   lvl1 = page title (frontmatter title or h1)
+*   lvl2-lvl6 = headings h2-h6
+*   content = first paragraph/list items after each heading
+*/
+var docuConfig$5 = loadDocuConfig();
+function getSectionTitle(filePath) {
+	const parts = filePath.split("/");
+	if (parts.length > 1) {
+		const section = docuConfig$5.routes?.find((r) => r.href === `/${parts[0]}` || r.href === parts[0]);
+		if (section) return section.title;
+	}
+	return docuConfig$5.meta?.title || "Docs";
+}
+function slugify(text) {
+	return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function stripJsx(content) {
+	let result = content;
+	let prev = "";
+	while (result !== prev) {
+		prev = result;
+		result = result.replace(/<[A-Z][\w.]*[\s\S]*?\/>/g, "").replace(/<[A-Z][\w.]*[\s\S]*?>([\s\S]*?)<\/[A-Z][\w.]*>/g, "$1");
+	}
+	return result;
+}
+function extractRecords(filePath, raw) {
+	const { frontmatter, strippedContent: content } = extractFrontmatterWithContent(raw);
+	const records = [];
+	const url = docsHtmlHref(`/docs/${filePath}`);
+	const lvl0 = getSectionTitle(filePath);
+	const lvl1 = frontmatterField(frontmatter, "title") || null;
+	const hierarchy = {
+		lvl0,
+		lvl1,
+		lvl2: null,
+		lvl3: null,
+		lvl4: null,
+		lvl5: null,
+		lvl6: null
+	};
+	if (lvl1) records.push({
+		url,
+		hierarchy: { ...hierarchy },
+		content: frontmatterField(frontmatter, "description") || null,
+		type: "lvl1"
+	});
+	const lines = stripJsx(content).split("\n");
+	let currentParagraph = [];
+	let inCodeBlock = false;
+	const flushParagraph = () => {
+		if (currentParagraph.length > 0) {
+			const text = currentParagraph.join(" ").trim();
+			if (text) records.push({
+				url: buildAnchorUrl(),
+				hierarchy: { ...hierarchy },
+				content: text,
+				type: "content"
+			});
+			currentParagraph = [];
+		}
+	};
+	const buildAnchorUrl = () => {
+		for (let i = 6; i >= 2; i--) {
+			const key = `lvl${i}`;
+			if (hierarchy[key]) return `${url}#${slugify(hierarchy[key])}`;
+		}
+		return url;
+	};
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("```")) {
+			inCodeBlock = !inCodeBlock;
+			continue;
+		}
+		if (inCodeBlock) continue;
+		if (/^import\s+[\w{*]/.test(trimmed) || /^export\s+[\w{*]/.test(trimmed)) continue;
+		const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
+		if (headingMatch) {
+			flushParagraph();
+			const level = headingMatch[1].length;
+			const title = headingMatch[2].replace(/[*`[\]]/g, "").trim();
+			for (let i = level; i <= 6; i++) hierarchy[`lvl${i}`] = null;
+			hierarchy[`lvl${level}`] = title;
+			if (level === 1 && !hierarchy.lvl1) hierarchy.lvl1 = title;
+			if (level >= 2) records.push({
+				url: `${url}#${slugify(title)}`,
+				hierarchy: { ...hierarchy },
+				content: null,
+				type: `lvl${level}`
+			});
+			continue;
+		}
+		if (trimmed === "" || trimmed === "---") {
+			flushParagraph();
+			continue;
+		}
+		if (/^\|.+\|/.test(trimmed)) continue;
+		const cleaned = trimmed.replace(/^[-*+]\s+/, "").replace(/^\d+\.\s+/, "").replace(/^>\s+/, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").trim();
+		if (cleaned) currentParagraph.push(cleaned);
+	}
+	flushParagraph();
+	return records;
+}
+async function generateSearchIndex(docsDir, outputDir) {
+	const docs = resolve(docsDir || DOCS_DIR);
+	const dist = resolve(outputDir || ASSETS_DIR);
+	await mkdir(dist, { recursive: true });
+	const mdxFiles = await scanMdxFiles(docs);
+	const allRecords = (await Promise.all(mdxFiles.map(async (file) => {
+		const raw = getPageContent(`/${file.path}`) ?? await readFile(file.absPath, "utf-8");
+		return extractRecords(file.path, raw);
+	}))).flat();
+	await writeFile(join(dist, "search-index.json"), JSON.stringify(allRecords));
+	return allRecords.length;
+}
+//#endregion
+//#region .docu/node/sentry.ts
+/**
+* Optional Sentry error tracking integration.
+* Active only when SENTRY_DSN environment variable is set.
+* Requires @sentry/bun as an optional peer dependency.
+*/
+var sentry = null;
+var initialized = false;
+async function initSentry() {
+	const dsn = process.env.SENTRY_DSN;
+	if (!dsn) return;
+	try {
+		sentry = await import("@sentry/bun");
+		sentry.init({
+			dsn,
+			environment: process.env.NODE_ENV || "development",
+			release: process.env.SENTRY_RELEASE || void 0
+		});
+		initialized = true;
+	} catch {
+		sentry = null;
+		initialized = false;
+	}
+}
+function captureException(err, context) {
+	if (!initialized || !sentry) return;
+	sentry.captureException(err, context ? { extra: context } : void 0);
+}
+//#endregion
+//#region .docu/components/Breadcrumb.tsx
+function toTitleCase(input) {
+	return input.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function DocsBreadcrumb({ paths }) {
+	return /* @__PURE__ */ jsx(Breadcrumb, {
+		className: "py-4",
+		children: /* @__PURE__ */ jsxs(BreadcrumbList, { children: [/* @__PURE__ */ jsx(BreadcrumbItem, { children: /* @__PURE__ */ jsx("span", {
+			className: "text-muted-foreground",
+			children: "Docs"
+		}) }), paths.map((path, index) => /* @__PURE__ */ jsx(BreadcrumbItem, { children: index < paths.length - 1 ? /* @__PURE__ */ jsx("span", {
+			className: "text-muted-foreground",
+			children: toTitleCase(path)
+		}) : /* @__PURE__ */ jsx(BreadcrumbPage, {
+			className: "text-base-content",
+			children: toTitleCase(path)
+		}) }, `${path}-${index}`))] })
+	});
+}
+var routes$1 = resolveRoutes(loadDocuConfig().routes);
+function flattenRoutes() {
+	const paths = [];
+	function traverse(route, section = "") {
+		const fullPath = route.href.startsWith(section) ? route.href : `${section}${route.href}`.replace(/\/+/g, "/");
+		if (route.href && !route.noLink) paths.push(fullPath);
+		if (route.items) route.items.forEach((item) => traverse(item, fullPath));
+	}
+	routes$1.forEach((route) => traverse(route));
+	return paths;
+}
+function getRouteMap() {
+	const map = /* @__PURE__ */ new Map();
+	function traverse(route, section = "") {
+		const fullPath = route.href.startsWith(section) ? route.href : `${section}${route.href}`.replace(/\/+/g, "/");
+		map.set(fullPath, route.title);
+		if (route.items) route.items.forEach((item) => traverse(item, fullPath));
+	}
+	routes$1.forEach((route) => traverse(route));
+	return map;
+}
+/**
+* Frontmatter for a page — read from the parse-once registry (populated
+* during compilation) instead of re-reading + re-parsing the file. Falls
+* back to a direct read only for pages the dev server has not compiled yet,
+* and caches the result back into the registry.
+*/
+function readPageFrontmatter(href) {
+	const registered = getPageFrontmatter(href);
+	if (registered) return registered;
+	let fm = {};
+	const rel = href.replace(/^\/|$/g, "");
+	for (const ext of [".mdx", ".md"]) {
+		for (const file of [join(DOCS_DIR, `${rel}${ext}`), join(DOCS_DIR, `${rel}/index${ext}`)]) try {
+			fm = extractFrontmatter(readFileSync(file, "utf-8"));
+			break;
+		} catch {}
+		if (Object.keys(fm).length) break;
+	}
+	registerPageFrontmatter(href, fm);
+	return fm;
+}
+function getPreviousNext(pathname) {
+	const normalizedPath = pathname.replace(/^\/|$/g, "");
+	if (normalizedPath === "docs" || normalizedPath === "") {
+		const paths = flattenRoutes();
+		const routeMap = getRouteMap();
+		const first = paths[0];
+		if (!first) return {
+			prev: null,
+			next: null
+		};
+		const fm = readPageFrontmatter(first);
+		return {
+			prev: null,
+			next: {
+				href: first,
+				title: fm.title || routeMap.get(first) || "",
+				description: fm.description || ""
+			}
+		};
+	}
+	const paths = flattenRoutes();
+	const index = paths.findIndex((href) => href === `/${normalizedPath}` || href === normalizedPath);
+	if (index === -1) return {
+		prev: null,
+		next: null
+	};
+	const routeMap = getRouteMap();
+	const prevHref = index > 0 ? paths[index - 1] : null;
+	const nextHref = index < paths.length - 1 ? paths[index + 1] : null;
+	const prevFm = prevHref ? readPageFrontmatter(prevHref) : null;
+	const nextFm = nextHref ? readPageFrontmatter(nextHref) : null;
+	return {
+		prev: prevHref ? {
+			href: prevHref,
+			title: prevFm?.title || routeMap.get(prevHref) || ""
+		} : null,
+		next: nextHref ? {
+			href: nextHref,
+			title: nextFm?.title || routeMap.get(nextHref) || "",
+			description: nextFm?.description || ""
+		} : null
+	};
+}
+//#endregion
+//#region .docu/components/Pagination.tsx
+function Pagination({ pathname, className, prevIcon, nextIcon, linkClassName }) {
+	const { prev, next } = getPreviousNext(pathname);
+	if (!prev && !next) return null;
+	return /* @__PURE__ */ jsx(PaginationDocs, {
+		prev: prev ? {
+			href: docsHtmlHref(`/docs${prev.href}`),
+			title: prev.title
+		} : void 0,
+		next: next ? {
+			href: docsHtmlHref(`/docs${next.href}`),
+			title: next.title,
+			description: next.description
+		} : void 0,
+		className,
+		prevIcon,
+		nextIcon,
+		linkClassName
+	});
+}
+//#endregion
+//#region .docu/components/Typography.tsx
+function Typography({ children }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "prose prose-zinc dark:prose-invert prose-code:font-code dark:prose-code:bg-stone-900/25 prose-code:bg-stone-50 prose-pre:bg-background max-lg:prose-headings:scroll-mt-16 prose-headings:scroll-mt-4 prose-code:text-sm prose-code:leading-6 dark:prose-code:text-white prose-code:text-stone-800 prose-code:p-1 prose-code:rounded-md prose-code:border prose-img:rounded-md prose-img:border prose-code:before:content-none prose-code:after:content-none prose-code:px-1.5 prose-code:overflow-x-auto prose-img:my-3 prose-h2:my-4 prose-h2:mt-8 w-full max-w-full! pt-2",
+		children
+	});
+}
+//#endregion
+//#region .docu/node/helpers.ts
+var docuConfig$3 = loadDocuConfig();
+function getEditLink(url, filePath) {
+	const configPath = docuConfig$3?.repo?.path || detectPlatformPath(url);
+	const encodedPath = filePath.replace(/^\//, "").split("/").map(encodeURIComponent).join("/");
+	return `${url}/${configPath}`.replace("{filePath}", encodedPath);
+}
+/**
+* Detect the default edit path template from the repo URL hostname.
+* Supports GitHub, GitLab, Bitbucket, Gitea (cloud + self-hosted),
+* Gogs, Forgejo, and Codeberg.
+* Falls back to Gitea-style for unknown hosts — override via repo.path.
+*/
+function detectPlatformPath(url) {
+	try {
+		const host = new URL(url).hostname;
+		if (host === "github.com") return "blob/main/{filePath}";
+		if (host === "gitlab.com") return "-/blob/main/{filePath}";
+		if (host === "bitbucket.org") return "src/main/{filePath}";
+		if (host === "gitea.com") return "src/branch/main/{filePath}";
+		if (host === "codeberg.org") return "src/branch/main/{filePath}";
+		return "src/branch/main/{filePath}";
+	} catch {
+		return "blob/main/{filePath}";
+	}
+}
+function isEditEnabled() {
+	return docuConfig$3?.repo?.edit ?? false;
+}
+function getRepoUrl() {
+	return docuConfig$3?.repo?.url || "";
+}
+function getSocialLinks() {
+	return docuConfig$3?.footer?.social || [];
+}
+//#endregion
+//#region .docu/components/EditWith.tsx
+function EditWith({ filePath, text = "Edit this page", className = "" }) {
+	if (!isEditEnabled()) return null;
+	const repoUrl = getRepoUrl();
+	if (!repoUrl) return null;
+	const editUrl = getEditLink(repoUrl, filePath);
+	return /* @__PURE__ */ jsx("div", {
+		className: `text-right text-sm ${className}`,
+		children: /* @__PURE__ */ jsxs("a", {
+			href: editUrl,
+			target: "_blank",
+			rel: "noopener noreferrer",
+			"aria-label": "Edit this page",
+			className: "flex items-center gap-1 no-underline",
+			children: [/* @__PURE__ */ jsx(SquarePen, { className: "h-4 w-4" }), text]
+		})
+	});
+}
+//#endregion
+//#region .docu/components/Social.tsx
+function createIcon(pathData) {
+	return function Icon({ className = "", size = 20 }) {
+		return /* @__PURE__ */ jsx("svg", {
+			className,
+			width: size,
+			height: size,
+			viewBox: "0 0 24 24",
+			xmlns: "http://www.w3.org/2000/svg",
+			fill: "currentColor",
+			children: /* @__PURE__ */ jsx("path", { d: pathData })
+		});
+	};
+}
+var GithubIcon = createIcon("M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12");
+var BitbucketIcon = createIcon("M.778 1.213a.768.768 0 00-.768.892l3.263 19.81c.084.5.515.868 1.022.873H19.95a.772.772 0 00.77-.646l3.27-20.03a.768.768 0 00-.768-.891zM14.52 15.53H9.522L8.17 8.466h7.561z");
+var GitlabIcon = createIcon("m23.6004 9.5927-.0337-.0862L20.3.9814a.851.851 0 0 0-.3362-.405.8748.8748 0 0 0-.9997.0539.8748.8748 0 0 0-.29.4399l-2.2055 6.748H7.5375l-2.2057-6.748a.8573.8573 0 0 0-.29-.4412.8748.8748 0 0 0-.9997-.0537.8585.8585 0 0 0-.3362.4049L.4332 9.5015l-.0325.0862a6.0657 6.0657 0 0 0 2.0119 7.0105l.0113.0087.03.0213 4.976 3.7264 2.462 1.8633 1.4995 1.1321a1.0085 1.0085 0 0 0 1.2197 0l1.4995-1.1321 2.4619-1.8633 5.006-3.7489.0125-.01a6.0682 6.0682 0 0 0 2.0094-7.003z");
+var NpmIcon = createIcon("M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z");
+var YoutubeIcon = createIcon("M23.498 6.186a3.016 3.016 0 0 0-2.122-2.136C19.505 3.545 12 3.545 12 3.545s-7.505 0-9.377.505A3.017 3.017 0 0 0 .502 6.186C0 8.07 0 12 0 12s0 3.93.502 5.814a3.016 3.016 0 0 0 2.122 2.136c1.871.505 9.376.505 9.376.505s7.505 0 9.377-.505a3.015 3.015 0 0 0 2.122-2.136C24 15.93 24 12 24 12s0-3.93-.502-5.814zM9.545 15.568V8.432L15.818 12l-6.273 3.568z");
+var TwitterIcon = createIcon("M14.234 10.162 22.977 0h-2.072l-7.591 8.824L7.251 0H.258l9.168 13.343L.258 24H2.33l8.016-9.318L16.749 24h6.993zm-2.837 3.299-.929-1.329L3.076 1.56h3.182l5.965 8.532.929 1.329 7.754 11.09h-3.182z");
+var iconMap = {
+	github: GithubIcon,
+	gitlab: GitlabIcon,
+	bitbucket: BitbucketIcon,
+	npm: NpmIcon,
+	youtube: YoutubeIcon,
+	twitter: TwitterIcon,
+	x: TwitterIcon,
+	instagram: createIcon("M7.0301.084c-1.2768.0602-2.1487.264-2.911.5634-.7888.3075-1.4575.72-2.1228 1.3877-.6652.6677-1.075 1.3368-1.3802 2.127-.2954.7638-.4956 1.6365-.552 2.914-.0564 1.2775-.0689 1.6882-.0626 4.947.0062 3.2586.0206 3.6671.0825 4.9473.061 1.2765.264 2.1482.5635 2.9107.308.7889.72 1.4573 1.388 2.1228.6679.6655 1.3365 1.0743 2.1285 1.38.7632.295 1.6361.4961 2.9134.552 1.2773.056 1.6884.069 4.9462.0627 3.2578-.0062 3.668-.0207 4.9478-.0814 1.28-.0607 2.147-.2652 2.9098-.5633.7889-.3086 1.4578-.72 2.1228-1.3881.665-.6682 1.0745-1.3378 1.3795-2.1284.2957-.7632.4966-1.636.552-2.9124.056-1.2809.0692-1.6898.063-4.948-.0063-3.2583-.021-3.6668-.0817-4.9465-.0607-1.2797-.264-2.1487-.5633-2.9117-.3084-.7889-.72-1.4568-1.3876-2.1228C21.2982 1.33 20.628.9208 19.8378.6165 19.074.321 18.2017.1197 16.9244.0645 15.6471.0093 15.236-.005 11.977.0014 8.718.0076 8.31.0215 7.0301.0839m.1402 21.6932c-1.17-.0509-1.8053-.2453-2.2287-.408-.5606-.216-.96-.4771-1.3819-.895-.422-.4178-.6811-.8186-.9-1.378-.1644-.4234-.3624-1.058-.4171-2.228-.0595-1.2645-.072-1.6442-.079-4.848-.007-3.2037.0053-3.583.0607-4.848.05-1.169.2456-1.805.408-2.2282.216-.5613.4762-.96.895-1.3816.4188-.4217.8184-.6814 1.3783-.9003.423-.1651 1.0575-.3614 2.227-.4171 1.2655-.06 1.6447-.072 4.848-.079 3.2033-.007 3.5835.005 4.8495.0608 1.169.0508 1.8053.2445 2.228.408.5608.216.96.4754 1.3816.895.4217.4194.6816.8176.9005 1.3787.1653.4217.3617 1.056.4169 2.2263.0602 1.2655.0739 1.645.0796 4.848.0058 3.203-.0055 3.5834-.061 4.848-.051 1.17-.245 1.8055-.408 2.2294-.216.5604-.4763.96-.8954 1.3814-.419.4215-.8181.6811-1.3783.9-.4224.1649-1.0577.3617-2.2262.4174-1.2656.0595-1.6448.072-4.8493.079-3.2045.007-3.5825-.006-4.848-.0608M16.953 5.5864A1.44 1.44 0 1 0 18.39 4.144a1.44 1.44 0 0 0-1.437 1.4424M5.8385 12.012c.0067 3.4032 2.7706 6.1557 6.173 6.1493 3.4026-.0065 6.157-2.7701 6.1506-6.1733-.0065-3.4032-2.771-6.1565-6.174-6.1498-3.403.0067-6.156 2.771-6.1496 6.1738M8 12.0077a4 4 0 1 1 4.008 3.9921A3.9996 3.9996 0 0 1 8 12.0077"),
+	linkedin: createIcon("M20.447 20.452h-3.554v-5.569c0-1.328-.027-3.037-1.852-3.037-1.853 0-2.136 1.445-2.136 2.939v5.667H9.351V9h3.414v1.561h.046c.477-.9 1.637-1.85 3.37-1.85 3.601 0 4.267 2.37 4.267 5.455v6.528zM5.337 7.433c-1.144 0-2.063-.926-2.063-2.065 0-1.138.92-2.063 2.063-2.063 1.14 0 2.064.925 2.064 2.063 0 1.139-.925 2.065-2.064 2.065zm1.782 13.019H3.555V9h3.564v11.452zM22.225 0H1.771C.792 0 0 .774 0 1.729v20.542C0 23.226.792 24 1.771 24h20.451C23.2 24 24 23.226 24 22.271V1.729C24 .774 23.2 0 22.222 0h.003z"),
+	facebook: createIcon("M9.101 23.691v-7.98H6.627v-3.667h2.474v-1.58c0-4.085 1.848-5.978 5.858-5.978.401 0 .955.042 1.468.103a8.68 8.68 0 0 1 1.141.195v3.325a8.623 8.623 0 0 0-.653-.036 26.805 26.805 0 0 0-.733-.009c-.707 0-1.259.096-1.675.309a1.686 1.686 0 0 0-.679.622c-.258.42-.374.995-.374 1.752v1.297h3.919l-.386 2.103-.287 1.564h-3.246v8.245C19.396 23.238 24 18.179 24 12.044c0-6.627-5.373-12-12-12s-12 5.373-12 12c0 5.628 3.874 10.35 9.101 11.647Z"),
+	telegram: createIcon("M11.944 0A12 12 0 0 0 0 12a12 12 0 0 0 12 12 12 12 0 0 0 12-12A12 12 0 0 0 12 0a12 12 0 0 0-.056 0zm4.962 7.224c.1-.002.321.023.465.14a.506.506 0 0 1 .171.325c.016.093.036.306.02.472-.18 1.898-.962 6.502-1.36 8.627-.168.9-.499 1.201-.82 1.23-.696.065-1.225-.46-1.9-.902-1.056-.693-1.653-1.124-2.678-1.8-1.185-.78-.417-1.21.258-1.91.177-.184 3.247-2.977 3.307-3.23.007-.032.014-.15-.056-.212s-.174-.041-.249-.024c-.106.024-1.793 1.14-5.061 3.345-.48.33-.913.49-1.302.48-.428-.008-1.252-.241-1.865-.44-.752-.245-1.349-.374-1.297-.789.027-.216.325-.437.893-.663 3.498-1.524 5.83-2.529 6.998-3.014 3.332-1.386 4.025-1.627 4.476-1.635z"),
+	discord: createIcon("M20.317 4.3698a19.7913 19.7913 0 00-4.8851-1.5152.0741.0741 0 00-.0785.0371c-.211.3753-.4447.8648-.6083 1.2495-1.8447-.2762-3.68-.2762-5.4868 0-.1636-.3933-.4058-.8742-.6177-1.2495a.077.077 0 00-.0785-.037 19.7363 0 00-4.8852 1.515.0699.0699 0 00-.0321.0277C.5334 9.0458-.319 13.5799.0992 18.0578a.0824.0824 0 00.0312.0561c2.0528 1.5076 4.0413 2.4228 5.9929 3.0294a.0777.0777 0 00.0842-.0276c.4616-.6304.8731-1.2952 1.226-1.9942a.076.076 0 00-.0416-.1057c-.6528-.2476-1.2743-.5495-1.8722-.8923a.077.077 0 01-.0076-.1277c.1258-.0943.2517-.1923.3718-.2914a.0743.0743 0 01.0776-.0105c3.9278 1.7933 8.18 1.7933 12.0614 0a.0739.0739 0 01.0785.0095c.1202.099.246.1981.3728.2924a.077.077 0 01-.0066.1276 12.2986 12.2986 0 01-1.873.8914.0766.0766 0 00-.0407.1067c.3604.698.7719 1.3628 1.225 1.9932a.076.076 0 00.0842.0286c1.961-.6067 3.9495-1.5219 6.0023-3.0294a.077.077 0 00.0313-.0552c.5004-5.177-.8382-9.6739-3.5485-13.6604a.061.061 0 00-.0312-.0286zM8.02 15.3312c-1.1825 0-2.1569-1.0857-2.1569-2.419 0-1.3332.9555-2.4189 2.157-2.4189 1.2108 0 2.1757 1.0952 2.1568 2.419 0 1.3332-.9555 2.4189-2.1569 2.4189zm7.9748 0c-1.1825 0-2.1569-1.0857-2.1569-2.419 0-1.3332.9554-2.4189 2.1569-2.4189 1.2108 0 2.1757 1.0952 2.1568 2.419 0 1.3332-.946 2.4189-2.1568 2.4189Z"),
+	threads: createIcon("M12.186 24h-.007c-3.581-.024-6.334-1.205-8.184-3.509C2.35 18.44 1.5 15.586 1.472 12.01v-.017c.03-3.579.879-6.43 2.525-8.482C5.845 1.205 8.6.024 12.18 0h.014c2.746.02 5.043.725 6.826 2.098 1.677 1.29 2.858 3.13 3.509 5.467l-2.04.569c-1.104-3.96-3.898-5.984-8.304-6.015-2.91.022-5.11.936-6.54 2.717C4.307 6.504 3.616 8.914 3.589 12c.027 3.086.718 5.496 2.057 7.164 1.43 1.783 3.631 2.698 6.54 2.717 2.623-.02 4.358-.631 5.8-2.045 1.647-1.613 1.618-3.593 1.09-4.798-.31-.71-.873-1.3-1.634-1.75-.192 1.352-.622 2.446-1.284 3.272-.886 1.102-2.14 1.704-3.73 1.79-1.202.065-2.361-.218-3.259-.801-1.063-.689-1.685-1.74-1.752-2.964-.065-1.19.408-2.285 1.33-3.082.88-.76 2.119-1.207 3.583-1.291a13.853 13.853 0 0 1 3.02.142c-.126-.742-.375-1.332-.75-1.757-.513-.586-1.308-.883-2.359-.89h-.029c-.844 0-1.992.232-2.721 1.32L7.734 7.847c.98-1.454 2.568-2.256 4.478-2.256h.044c3.194.02 5.097 1.975 5.287 5.388.108.046.216.094.321.142 1.49.7 2.58 1.761 3.154 3.07.797 1.82.871 4.79-1.548 7.158-1.85 1.81-4.094 2.628-7.277 2.65Zm1.003-11.69c-.242 0-.487.007-.739.021-1.836.103-2.98.946-2.916 2.143.067 1.256 1.452 1.839 2.784 1.767 1.224-.065 2.818-.543 3.086-3.71a10.5 10.5 0 0 0-2.215-.221z"),
+	mastodon: createIcon("M23.268 5.313c-.35-2.578-2.617-4.61-5.304-5.004C17.51.242 15.792 0 11.813 0h-.03c-3.98 0-4.835.242-5.288.309C3.882.692 1.496 2.518.917 5.127.64 6.412.61 7.837.661 9.143c.074 1.874.088 3.745.26 5.611.118 1.24.325 2.47.62 3.68.55 2.237 2.777 4.098 4.96 4.857 2.336.792 4.849.923 7.256.38.265-.061.527-.132.786-.213.585-.184 1.27-.39 1.774-.753a.057.057 0 0 0 .023-.043v-1.809a.052.052 0 0 0-.02-.041.053.053 0 0 0-.046-.01 20.282 20.282 0 0 1-4.709.545c-2.73 0-3.463-1.284-3.674-1.818a5.593 5.593 0 0 1-.319-1.433.053.053 0 0 1 .066-.054c1.517.363 3.072.546 4.632.546.376 0 .75 0 1.125-.01 1.57-.044 3.224-.124 4.768-.422.038-.008.077-.015.11-.024 2.435-.464 4.753-1.92 4.989-5.604.008-.145.03-1.52.03-1.67.002-.512.167-3.63-.024-5.545zm-3.748 9.195h-2.561V8.29c0-1.309-.55-1.976-1.67-1.976-1.23 0-1.846.79-1.846 2.35v3.403h-2.546V8.663c0-1.56-.617-2.35-1.848-2.35-1.112 0-1.668.668-1.67 1.977v6.218H4.822V8.102c0-1.31.337-2.35 1.011-3.12.696-.77 1.608-1.164 2.74-1.164 1.311 0 2.302.5 2.962 1.498l.638 1.06.638-1.06c.66-.999 1.65-1.498 2.96-1.498 1.13 0 2.043.395 2.74 1.164.675.77 1.012 1.81 1.012 3.12z")
+};
+function getSocialIcon(name) {
+	return iconMap[name.toLowerCase().replace(/\s+/g, "")] || null;
+}
+function Social({ className = "", size = 16 }) {
+	const socialLinks = getSocialLinks();
+	if (!socialLinks?.length) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: `flex gap-1 ${className}`,
+		children: socialLinks.map((link) => {
+			const Icon = getSocialIcon(link.name);
+			return /* @__PURE__ */ jsx("a", {
+				href: link.url,
+				target: "_blank",
+				rel: "noopener noreferrer",
+				"aria-label": link.name,
+				className: "btn-xs btn-circle btn-ghost text-muted-foreground",
+				children: Icon && /* @__PURE__ */ jsx(Icon, { size })
+			}, link.name);
+		})
+	});
+}
+//#endregion
+//#region .docu/components/Footer.tsx
+function Footer() {
+	return /* @__PURE__ */ jsxs("footer", {
+		className: "text-muted-foreground mt-auto flex w-full flex-col items-start gap-4 py-6 sm:flex-row sm:items-center sm:justify-between",
+		children: [/* @__PURE__ */ jsx(Social, {}), /* @__PURE__ */ jsx("aside", {
+			className: "sm:ml-auto",
+			children: /* @__PURE__ */ jsxs("p", {
+				className: "text-xs",
+				children: [
+					"Made with",
+					" ",
+					/* @__PURE__ */ jsx("a", {
+						href: "https://docubook.pro",
+						target: "_blank",
+						rel: "noopener noreferrer",
+						className: "link link-hover text-muted-foreground font-medium",
+						children: "DocuBook"
+					})
+				]
+			})
+		})]
+	});
+}
+//#endregion
+//#region .docu/components/ScrollTo.tsx
+function ScrollTo({ className, showIcon = true, onScrollToTop }) {
+	const [isVisible, setIsVisible] = useState(false);
+	const checkScroll = useCallback(() => {
+		const container = document.getElementById("scroll-container");
+		const shouldShow = (container ? container.scrollTop : window.scrollY) > (container ? container.scrollHeight : document.documentElement.scrollHeight) * .3;
+		if (shouldShow !== isVisible) setIsVisible(shouldShow);
+	}, [isVisible]);
+	useEffect(() => {
+		let timeoutId;
+		const handleScroll = () => {
+			if (timeoutId) clearTimeout(timeoutId);
+			timeoutId = setTimeout(checkScroll, 100);
+		};
+		const container = document.getElementById("scroll-container") || window;
+		container.addEventListener("scroll", handleScroll, { passive: true });
+		return () => {
+			container.removeEventListener("scroll", handleScroll);
+			if (timeoutId) clearTimeout(timeoutId);
+		};
+	}, [checkScroll]);
+	const scrollToTop = useCallback((e) => {
+		e.preventDefault();
+		onScrollToTop?.();
+		history.replaceState(null, "", "#top");
+		const container = document.getElementById("scroll-container");
+		if (container) container.scrollTo({
+			top: 0,
+			behavior: "smooth"
+		});
+		else window.scrollTo({
+			top: 0,
+			behavior: "smooth"
+		});
+	}, [onScrollToTop]);
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("border-base-300 mt-4 border-t pt-4", "transition-opacity duration-300", isVisible ? "opacity-100" : "pointer-events-none opacity-0", className),
+		children: /* @__PURE__ */ jsxs("a", {
+			href: "#top",
+			onClick: scrollToTop,
+			className: cn("inline-flex items-center text-sm", "link link-hover text-base-content/60 hover:text-base-content", "transition-all duration-200 hover:translate-y-px"),
+			"aria-label": "Scroll to top",
+			children: [showIcon && /* @__PURE__ */ jsx(ArrowUpIcon, { className: "mr-1 h-3.5 w-3.5 shrink-0" }), /* @__PURE__ */ jsx("span", { children: "Scroll to Top" })]
+		})
+	});
+}
+//#endregion
+//#region .docu/components/Toc.tsx
+function Toc({ tocs }) {
+	const [activeId, setActiveId] = useState(null);
+	const clickedIdRef = useRef(null);
+	const clickTimerRef = useRef(null);
+	const activeIdRef = useRef(null);
+	useEffect(() => {
+		activeIdRef.current = activeId;
+	}, [activeId]);
+	const getAnchorOffset = useCallback(() => {
+		if (typeof window === "undefined") return 100;
+		const first = tocs[0] ? document.getElementById(tocs[0].href.slice(1)) : null;
+		return (first ? parseFloat(getComputedStyle(first).scrollMarginTop) : 0) || 100;
+	}, [tocs]);
+	useEffect(() => {
+		if (typeof window === "undefined" || window.innerWidth < 1024) return;
+		if (!tocs.length) return;
+		const container = window.innerWidth >= 1024 ? document.getElementById("scroll-container") : null;
+		const scrollTarget = container || window;
+		const offset = getAnchorOffset();
+		const handleScroll = () => {
+			if (clickedIdRef.current) return;
+			let currentId = null;
+			for (const toc of tocs) {
+				const id = toc.href.slice(1);
+				const el = document.getElementById(id);
+				if (!el) continue;
+				if ((container ? el.offsetTop - container.scrollTop : el.getBoundingClientRect().top) <= offset) currentId = id;
+				else break;
+			}
+			if (currentId !== activeIdRef.current) {
+				setActiveId(currentId);
+				history.replaceState(null, "", currentId ? `#${currentId}` : "#top");
+			}
+		};
+		handleScroll();
+		let throttleTimer = null;
+		const listener = tocs.length > 30 ? () => {
+			if (throttleTimer) return;
+			throttleTimer = setTimeout(() => {
+				throttleTimer = null;
+				handleScroll();
+			}, 50);
+		} : handleScroll;
+		scrollTarget.addEventListener("scroll", listener, { passive: true });
+		return () => {
+			scrollTarget.removeEventListener("scroll", listener);
+			if (throttleTimer) clearTimeout(throttleTimer);
+		};
+	}, [tocs, getAnchorOffset]);
+	const handleLinkClick = useCallback((id) => {
+		clickedIdRef.current = id;
+		setActiveId(id);
+		history.replaceState(null, "", `#${id}`);
+		if (clickTimerRef.current) clearTimeout(clickTimerRef.current);
+		clickTimerRef.current = setTimeout(() => {
+			clickedIdRef.current = null;
+		}, 1e3);
+	}, []);
+	const handleScrollToTop = useCallback(() => {
+		clickedIdRef.current = "__top__";
+		setActiveId(null);
+		history.replaceState(null, "", "#top");
+		if (clickTimerRef.current) clearTimeout(clickTimerRef.current);
+		clickTimerRef.current = setTimeout(() => {
+			clickedIdRef.current = null;
+		}, 1e3);
+	}, []);
+	useEffect(() => {
+		return () => {
+			if (clickTimerRef.current) clearTimeout(clickTimerRef.current);
+		};
+	}, []);
+	const activeItemRef = useRef(null);
+	useEffect(() => {
+		if (activeId && activeItemRef.current && !clickedIdRef.current) activeItemRef.current.scrollIntoView({
+			block: "nearest",
+			behavior: "smooth"
+		});
+	}, [activeId]);
+	if (!tocs.length) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex h-full min-h-0 w-full flex-col gap-2",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "flex shrink-0 items-center gap-2",
+			children: [/* @__PURE__ */ jsx(ListIcon, { className: "h-4 w-4" }), /* @__PURE__ */ jsx("h3", {
+				className: "text-sm font-medium",
+				children: "On this page"
+			})]
+		}), /* @__PURE__ */ jsxs("div", {
+			className: "relative min-h-0 flex-1 overflow-y-auto overscroll-contain pr-1",
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: "relative text-sm",
+				children: [/* @__PURE__ */ jsx("div", { className: "bg-base-300 absolute top-0 left-0 h-full w-px" }), /* @__PURE__ */ jsx("div", {
+					className: "flex flex-col",
+					children: tocs.map(({ href, level, text }) => {
+						const id = href.slice(1);
+						const isActive = activeId === id;
+						const levelPadding = (level - 2) * 16;
+						return /* @__PURE__ */ jsxs("div", {
+							ref: isActive ? activeItemRef : void 0,
+							className: cn("relative flex items-center transition-all duration-200", isActive && "bg-primary/5"),
+							children: [/* @__PURE__ */ jsxs("div", {
+								className: cn("flex shrink-0 items-center px-1 py-2 transition-all duration-200", isActive && "border-primary -ml-px border-l-[3px]"),
+								children: [/* @__PURE__ */ jsx("div", { className: cn("h-px transition-colors duration-200", isActive ? "bg-primary w-3" : "bg-base-300 w-2") }), /* @__PURE__ */ jsx("div", { className: cn("h-1.5 w-1.5 shrink-0 rounded-full transition-colors duration-300", isActive ? "bg-primary" : "bg-base-300") })]
+							}), /* @__PURE__ */ jsx("a", {
+								href,
+								onClick: (e) => {
+									e.preventDefault();
+									handleLinkClick(id);
+									const el = document.getElementById(id);
+									if (el) {
+										const offset = getAnchorOffset();
+										const scroller = window.innerWidth >= 1024 ? document.getElementById("scroll-container") : null;
+										const elTop = el.getBoundingClientRect().top;
+										if (scroller) scroller.scrollTo({
+											top: elTop - scroller.getBoundingClientRect().top + scroller.scrollTop - offset,
+											behavior: "smooth"
+										});
+										else window.scrollTo({
+											top: elTop + window.scrollY - offset,
+											behavior: "smooth"
+										});
+									}
+								},
+								className: cn("flex flex-1 items-center py-2 transition-all duration-200", isActive ? "text-primary font-medium" : "text-base-content/60 hover:text-base-content"),
+								style: { paddingLeft: `${levelPadding + 6}px` },
+								children: /* @__PURE__ */ jsx("span", {
+									className: "line-clamp-2 text-sm break-words",
+									children: text
+								})
+							})]
+						}, href);
+					})
+				})]
+			}), /* @__PURE__ */ jsxs("div", {
+				className: "mt-2 grid grid-cols-[28px_minmax(0,1fr)] items-start px-4 text-sm",
+				children: [/* @__PURE__ */ jsx("div", { "aria-hidden": "true" }), /* @__PURE__ */ jsx(ScrollTo, {
+					className: "mt-0",
+					onScrollToTop: handleScrollToTop
+				})]
+			})]
+		})]
+	});
+}
+//#endregion
+//#region .docu/pages/docs/[[...slug]].tsx
+function DocsPage({ slug, title, description, date, content, tocs, filePath, repoUrl, mdxSlug, compiledSource }) {
+	const pathname = slug.join("/");
+	const tocsJson = JSON.stringify(tocs);
+	return /* @__PURE__ */ jsx("div", {
+		className: "flex w-full flex-1 px-0 pb-4 lg:h-[calc(100vh-4rem)] lg:px-8 lg:pb-8",
+		children: /* @__PURE__ */ jsxs("div", {
+			id: "scroll-container",
+			className: "bg-base-100 border-base-300 relative flex w-full flex-col items-start rounded-b-3xl border shadow-md max-lg:scroll-p-54 lg:h-full lg:flex-row lg:overflow-y-auto lg:rounded-xl",
+			children: [/* @__PURE__ */ jsx("div", {
+				id: "mobile-bar-island",
+				className: "sticky top-0 z-50 w-full lg:hidden",
+				"data-tocs": tocsJson,
+				"data-title": title,
+				"data-repo": repoUrl || ""
+			}), /* @__PURE__ */ jsxs("div", {
+				className: "flex w-full flex-col lg:flex-row 2xl:mx-auto 2xl:max-w-[1300px]",
+				children: [/* @__PURE__ */ jsxs("div", {
+					className: `w-full min-w-0 ${tocs.length > 0 ? "flex-[7]" : "mx-auto max-w-[820px]"} px-4 py-6 lg:px-12 lg:py-10`,
+					children: [/* @__PURE__ */ jsx(DocsBreadcrumb, { paths: slug }), /* @__PURE__ */ jsxs(Typography, { children: [
+						/* @__PURE__ */ jsx("h1", {
+							className: "-mt-0.5 text-3xl",
+							children: title
+						}),
+						description && /* @__PURE__ */ jsx("p", {
+							className: "text-muted-foreground -mt-4 text-[16.5px]",
+							children: description
+						}),
+						/* @__PURE__ */ jsx("div", {
+							id: "mdx-content-island",
+							"data-mdx-slug": mdxSlug,
+							dangerouslySetInnerHTML: { __html: content }
+						}),
+						compiledSource && /* @__PURE__ */ jsx("script", {
+							id: "mdx-compiled-source",
+							type: "application/json",
+							dangerouslySetInnerHTML: { __html: JSON.stringify(compiledSource).replace(/<\//g, "\\u003C/") }
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: "border-base-300 my-8 flex items-center border-b-2 border-dashed",
+							children: [/* @__PURE__ */ jsx(EditWith, {
+								className: "text-muted-foreground",
+								filePath
+							}), date && /* @__PURE__ */ jsxs("p", {
+								className: "text-muted-foreground ml-auto text-[13px]",
+								children: ["Last updated ", formatDate2(date)]
+							})]
+						}),
+						/* @__PURE__ */ jsx(Pagination, {
+							pathname,
+							prevIcon: /* @__PURE__ */ jsx(ChevronLeft, { className: "h-3 w-3" }),
+							nextIcon: /* @__PURE__ */ jsx(ChevronRight, { className: "h-3 w-3" })
+						}),
+						/* @__PURE__ */ jsx(Footer, {})
+					] })]
+				}), tocs.length > 0 && /* @__PURE__ */ jsx("div", {
+					id: "toc-island",
+					"data-tocs": tocsJson,
+					className: "sticky top-4 hidden h-[calc(100vh-8rem)] min-w-[240px] flex-[3] self-start lg:flex lg:px-4 lg:py-6",
+					children: /* @__PURE__ */ jsx(Toc, { tocs })
+				})]
+			})]
+		})
+	});
+}
+//#endregion
+//#region .docu/pages/404.tsx
+function NotFoundPage() {
+	return /* @__PURE__ */ jsx("div", {
+		className: "flex w-full flex-1 px-4 py-8 lg:h-[calc(100vh-4rem)] lg:px-8 lg:py-4",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "bg-base-100 border-base-300 flex min-h-[50vh] w-full flex-col items-center justify-center rounded-xl border shadow-md lg:min-h-0 lg:flex-1",
+			children: [
+				/* @__PURE__ */ jsx("h1", {
+					className: "text-6xl font-bold",
+					children: "404"
+				}),
+				/* @__PURE__ */ jsx("p", {
+					className: "text-base-content/60 py-4 text-xl",
+					children: "Page not found"
+				}),
+				/* @__PURE__ */ jsx("a", {
+					href: "/docs/",
+					className: "btn btn-primary mt-2",
+					children: "Go to Docs"
+				})
+			]
+		})
+	});
+}
+//#endregion
+//#region .docu/components/Lucide.tsx
+/**
+* Get Lucide icon component by name
+* Icon names must match Lucide's export names exactly (e.g., "Zap", "BookOpen", "Search")
+*/
+function getLucideIcon(name) {
+	if (!name) return null;
+	return LucideIcons[name] || null;
+}
+/**
+* Render Lucide icon component
+*/
+function renderLucideIcon(name, className) {
+	const Icon = getLucideIcon(name);
+	return Icon ? /* @__PURE__ */ jsx(Icon, { className }) : null;
+}
+//#endregion
+//#region .docu/components/home/Hero.tsx
+function isExternalLink(link) {
+	return /^https?:\/\//.test(link);
+}
+function renderActionButtonIcon(iconName, className) {
+	if (!iconName) return null;
+	const lucideIcon = renderLucideIcon(iconName, className);
+	if (lucideIcon) return lucideIcon;
+	const SocialIcon = getSocialIcon(iconName);
+	if (SocialIcon) return /* @__PURE__ */ jsx(SocialIcon, { className });
+	return null;
+}
+function ActionButton({ action }) {
+	const themeClasses = {
+		primary: "bg-primary text-primary-foreground hover:bg-primary/90",
+		secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/90",
+		ghost: "bg-transparent text-muted-foreground border border-base-300 hover:bg-base-200"
+	};
+	const isExternal = isExternalLink(action.link);
+	return /* @__PURE__ */ jsxs("a", {
+		href: action.link,
+		target: isExternal ? "_blank" : void 0,
+		rel: isExternal ? "noopener noreferrer" : void 0,
+		className: cn("inline-flex items-center gap-2 rounded-lg px-6 py-3 text-sm font-medium transition-colors", themeClasses[action.theme || "primary"]),
+		children: [renderActionButtonIcon(action.icon, "h-4 w-4"), action.text]
+	});
+}
+function Hero({ hero, className }) {
+	const { tagline, headline, description, actions } = hero;
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("mx-auto max-w-4xl px-6 py-32 sm:py-44", className),
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "text-center",
+			children: [
+				tagline && /* @__PURE__ */ jsx("p", {
+					className: "text-primary mb-4 text-lg font-semibold",
+					children: tagline
+				}),
+				/* @__PURE__ */ jsx("h1", {
+					className: "text-5xl font-semibold tracking-tight text-balance sm:text-7xl",
+					children: headline
+				}),
+				description && /* @__PURE__ */ jsx("p", {
+					className: "text-muted-foreground mt-8 text-lg text-pretty sm:text-xl",
+					children: description
+				}),
+				actions && actions.length > 0 && /* @__PURE__ */ jsx("div", {
+					className: "mt-10 flex flex-wrap items-center justify-center gap-4",
+					children: actions.map((action, index) => /* @__PURE__ */ jsx(ActionButton, { action }, index))
+				})
+			]
+		})
+	});
+}
+//#endregion
+//#region .docu/components/home/Features.tsx
+function FeatureCard({ feature, index }) {
+	const Wrapper = feature.link ? "a" : "div";
+	const wrapperProps = feature.link ? { href: feature.link } : {};
+	const patternId = `grid-${index}`;
+	return /* @__PURE__ */ jsxs(Wrapper, {
+		...wrapperProps,
+		className: cn("border-base-200 bg-base-100 hover:border-primary/40 group relative overflow-hidden rounded-2xl border p-6 transition-all hover:shadow-lg", feature.link && "cursor-pointer"),
+		children: [/* @__PURE__ */ jsxs("svg", {
+			className: "absolute inset-0 h-full w-full",
+			xmlns: "http://www.w3.org/2000/svg",
+			style: { color: "var(--color-primary)" },
+			"aria-hidden": "true",
+			children: [/* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsx("pattern", {
+				id: patternId,
+				width: "40",
+				height: "40",
+				patternUnits: "userSpaceOnUse",
+				children: /* @__PURE__ */ jsx("path", {
+					d: "M 40 0 L 0 0 0 40",
+					fill: "none",
+					stroke: "currentColor",
+					strokeWidth: "0.5",
+					opacity: "0.15"
+				})
+			}) }), /* @__PURE__ */ jsx("rect", {
+				width: "100%",
+				height: "100%",
+				fill: `url(#${patternId})`
+			})]
+		}), /* @__PURE__ */ jsxs("div", {
+			className: "relative z-10",
+			children: [
+				feature.icon && /* @__PURE__ */ jsx("div", {
+					className: "bg-primary/10 mb-4 inline-flex h-12 w-12 items-center justify-center rounded-lg",
+					children: renderLucideIcon(feature.icon, "h-6 w-6 text-primary")
+				}),
+				/* @__PURE__ */ jsx("h3", {
+					className: "mb-2 text-lg font-semibold",
+					children: feature.title
+				}),
+				/* @__PURE__ */ jsx("p", {
+					className: "text-muted-foreground text-sm",
+					children: feature.description
+				})
+			]
+		})]
+	});
+}
+function Features({ features, className }) {
+	if (!features || features.length === 0) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("mx-auto max-w-5xl px-6 pb-24", className),
+		children: /* @__PURE__ */ jsx("div", {
+			className: "grid grid-cols-1 gap-6 sm:grid-cols-2 lg:grid-cols-3",
+			children: features.map((feature, index) => /* @__PURE__ */ jsx(FeatureCard, {
+				feature,
+				index
+			}, index))
+		})
+	});
+}
+//#endregion
+//#region .docu/pages/index.tsx
+var docuConfig$2 = loadDocuConfig();
+function IndexPage() {
+	const { meta, home } = docuConfig$2;
+	const routes = docuConfig$2.routes || [];
+	const linkWithHtml = (link) => {
+		if (isExternalUrl(link)) return link;
+		if (link.startsWith("/docs/")) return `${link}.html`;
+		return link;
+	};
+	const features = home?.features?.map((f) => ({
+		...f,
+		link: f.link ? linkWithHtml(f.link) : void 0
+	})) || routes.filter((r) => r.context).map((route) => ({
+		icon: route.context?.icon,
+		title: route.context?.title || route.title,
+		description: route.context?.description || "",
+		link: docsHtmlHref(`/docs${route.href}${route.items?.[0]?.href || ""}`)
+	}));
+	const hero = home?.hero ? {
+		...home.hero,
+		actions: home.hero.actions?.map((a) => ({
+			...a,
+			link: linkWithHtml(a.link)
+		}))
+	} : {
+		headline: meta.title,
+		description: meta.description
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: "bg-base-100 relative isolate min-h-screen overflow-hidden",
+		children: [
+			/* @__PURE__ */ jsx("div", {
+				className: "absolute top-4 right-4 z-10",
+				id: "theme-island"
+			}),
+			/* @__PURE__ */ jsx("div", {
+				"aria-hidden": "true",
+				className: "pointer-events-none absolute -top-40 left-1/2 -z-10 -translate-x-1/2 blur-3xl sm:-top-80",
+				children: /* @__PURE__ */ jsx("div", {
+					style: { clipPath: "polygon(74.1% 44.1%, 100% 61.6%, 97.5% 26.9%, 85.5% 0.1%, 80.7% 2%, 72.5% 32.5%, 60.2% 62.4%, 52.4% 68.1%, 47.5% 58.3%, 45.2% 34.5%, 27.5% 76.7%, 0.1% 64.9%, 17.9% 100%, 27.6% 76.8%, 76.1% 97.7%, 74.1% 44.1%)" },
+					className: "from-primary to-accent h-[40rem] w-[80rem] bg-gradient-to-tr opacity-20"
+				})
+			}),
+			/* @__PURE__ */ jsx(Hero, { hero }),
+			/* @__PURE__ */ jsx(Features, { features }),
+			/* @__PURE__ */ jsx("div", {
+				"aria-hidden": "true",
+				className: "pointer-events-none absolute bottom-0 left-1/2 -z-10 translate-x-1/4 blur-3xl",
+				children: /* @__PURE__ */ jsx("div", {
+					style: { clipPath: "polygon(74.1% 44.1%, 100% 61.6%, 97.5% 26.9%, 85.5% 0.1%, 80.7% 2%, 72.5% 32.5%, 60.2% 62.4%, 52.4% 68.1%, 47.5% 58.3%, 45.2% 34.5%, 27.5% 76.7%, 0.1% 64.9%, 17.9% 100%, 27.6% 76.8%, 76.1% 97.7%, 74.1% 44.1%)" },
+					className: "from-accent to-primary h-[30rem] w-[70rem] bg-gradient-to-tr opacity-20"
+				})
+			})
+		]
+	});
+}
+//#endregion
+//#region .docu/components/Anchor.tsx
+function Anchor({ href = "", className = "", activeClassName = "", activeWhen, disabled = false, children, ...props }) {
+	const isActive = (() => {
+		if (!activeWhen || typeof window === "undefined") return false;
+		const pathname = window.location.pathname;
+		if (typeof activeWhen === "string") return pathname === activeWhen || pathname.endsWith(activeWhen);
+		if (activeWhen instanceof RegExp) return activeWhen.test(pathname);
+		if (typeof activeWhen === "function") return activeWhen(pathname);
+		return false;
+	})();
+	const isExternal = isExternalUrl(href);
+	const baseClasses = cn("hover:underline transition-colors", className, isActive ? activeClassName : "", disabled && "cursor-not-allowed opacity-50");
+	if (disabled) return /* @__PURE__ */ jsx("span", {
+		className: baseClasses,
+		children
+	});
+	if (isExternal) return /* @__PURE__ */ jsxs("a", {
+		href,
+		className: baseClasses,
+		target: "_blank",
+		rel: "noopener noreferrer",
+		...props,
+		children: [children, /* @__PURE__ */ jsx(ArrowUpRight, { className: "ml-0.5 inline-block h-3.5 w-3.5" })]
+	});
+	return /* @__PURE__ */ jsx("a", {
+		href,
+		className: baseClasses,
+		...props,
+		children
+	});
+}
+//#endregion
+//#region .docu/node/client-routes.ts
+var docuConfig$1 = loadDocuConfig();
+resolveRoutes(docuConfig$1.routes || []);
+var config = docuConfig$1;
+//#endregion
+//#region .docu/components/Sublink.tsx
+/** Exclusive accordion for level >= 2 sidebar groups — opening one group
+* closes the previously open one. All level >= 2 groups default to closed
+* and expand only when the header is clicked. `open` is used to auto-expand
+* the group containing the active page. */
+var GroupAccordionContext = createContext({
+	openId: null,
+	open: () => {},
+	toggle: () => {}
+});
+function GroupAccordionProvider({ children }) {
+	const [openId, setOpenId] = useState(null);
+	const open = useCallback((id) => setOpenId(id), []);
+	const toggle = useCallback((id) => setOpenId((prev) => prev === id ? null : id), []);
+	return /* @__PURE__ */ jsx(GroupAccordionContext.Provider, {
+		value: {
+			openId,
+			open,
+			toggle
+		},
+		children
+	});
+}
+function Sublink({ title, href, items, noLink, level, onNavigate, parentHref = "", pathname: pathnameProp }) {
+	const fullHref = parentHref ? `${parentHref}${href}` : `/docs${href}`;
+	const currentPathname = pathnameProp || (typeof window !== "undefined" ? window.location.pathname : "/docs");
+	const isSeparator = config.sidebar?.context === "separator";
+	const { openId, open, toggle } = useContext(GroupAccordionContext);
+	const isAccordionGroup = Boolean(items) && (isSeparator || level >= 1);
+	const treeLevel = level + (isSeparator ? 2 : 1);
+	const [isOpen, setIsOpen] = useState(() => {
+		if (isAccordionGroup) return false;
+		if (level === 0) return true;
+		return false;
+	});
+	const effectiveOpen = isAccordionGroup ? openId === fullHref : isOpen;
+	const handleToggle = () => {
+		if (isAccordionGroup) toggle(fullHref);
+		else setIsOpen((o) => !o);
+	};
+	const isInsideActive = currentPathname.startsWith(fullHref) && currentPathname !== fullHref;
+	useEffect(() => {
+		if (isAccordionGroup && isInsideActive) open(fullHref);
+	}, [
+		isAccordionGroup,
+		isInsideActive,
+		fullHref,
+		open
+	]);
+	const levelPadding = cn(level === 1 && "pl-4", level === 2 && "pl-8", level >= 3 && "pl-12");
+	const isActive = currentPathname === fullHref || currentPathname === `${fullHref}.html`;
+	const activeRef = useRef(null);
+	useEffect(() => {
+		if (isActive && activeRef.current) activeRef.current.scrollIntoView({ block: "nearest" });
+	}, [isActive]);
+	if (!items) {
+		const link = /* @__PURE__ */ jsx(Anchor, {
+			href: docsHtmlHref(fullHref),
+			className: "text-foreground hover:text-foreground/80 text-sm transition-colors",
+			activeClassName: "text-primary font-medium",
+			activeWhen: (path) => path === fullHref || path === `${fullHref}.html`,
+			onClick: onNavigate,
+			children: title
+		});
+		if (level >= 1) {
+			if (config.sidebar?.context === "separator") {
+				const sectionOffsets = {
+					1: 16,
+					2: 32
+				};
+				let overlap = 14;
+				for (let l = 1; l < level; l++) overlap += sectionOffsets[l] ?? 48;
+				return /* @__PURE__ */ jsx("div", {
+					ref: activeRef,
+					className: cn("border-l-2", isActive ? "border-primary" : "border-transparent"),
+					style: { marginLeft: `-${overlap}px` },
+					children: /* @__PURE__ */ jsx("div", {
+						className: cn("py-1 pl-3", levelPadding),
+						children: link
+					})
+				});
+			}
+			return /* @__PURE__ */ jsx("div", {
+				ref: activeRef,
+				className: cn("py-1", levelPadding, "border-l-2", isActive ? "border-primary" : "border-base-300"),
+				children: link
+			});
+		}
+		return /* @__PURE__ */ jsx("div", {
+			ref: activeRef,
+			className: cn("py-1", levelPadding),
+			children: link
+		});
+	}
+	return /* @__PURE__ */ jsxs("div", {
+		ref: isActive ? activeRef : void 0,
+		className: cn("flex flex-col", levelPadding),
+		children: [/* @__PURE__ */ jsxs("button", {
+			type: "button",
+			onClick: handleToggle,
+			className: cn("flex w-full cursor-pointer items-center justify-between py-1 text-left text-sm transition-colors", noLink && treeLevel === 1 ? "text-base-content font-semibold" : "text-foreground hover:text-foreground/80"),
+			children: [noLink ? /* @__PURE__ */ jsx("span", { children: title }) : /* @__PURE__ */ jsx(Anchor, {
+				href: docsHtmlHref(fullHref),
+				className: "text-foreground hover:text-foreground/80 transition-colors",
+				activeClassName: "text-primary",
+				activeWhen: (path) => path === fullHref || path === `${fullHref}.html`,
+				onClick: onNavigate,
+				children: title
+			}), /* @__PURE__ */ jsx(ChevronDown, { className: cn("text-base-content/40 h-4 w-4 shrink-0 transition-transform duration-200", effectiveOpen ? "rotate-0" : "-rotate-90") })]
+		}), effectiveOpen && /* @__PURE__ */ jsx("div", {
+			className: "flex flex-col py-1",
+			children: items.map((item) => /* @__PURE__ */ jsx(Sublink, {
+				...item,
+				href: item.href,
+				level: level + 1,
+				onNavigate,
+				parentHref: fullHref,
+				pathname: pathnameProp
+			}, `${fullHref}${item.href}`))
+		})]
+	});
+}
+//#endregion
+//#region .docu/components/SidebarGroupHeader.tsx
+function SidebarGroupHeader({ icon, title }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "sidebar-group-header mb-1.5 flex items-center gap-2.5 font-medium text-gray-900 dark:text-gray-200",
+		children: [icon && /* @__PURE__ */ jsx("span", {
+			className: "flex h-4 w-4 shrink-0 items-center justify-center",
+			children: renderLucideIcon(icon, "h-3.5 w-3.5")
+		}), /* @__PURE__ */ jsx("h3", {
+			className: "sidebar-title font-[inherit] text-[length:inherit] leading-[inherit]",
+			children: /* @__PURE__ */ jsx("span", { children: title })
+		})]
+	});
+}
+//#endregion
+//#region .docu/components/Menu.tsx
+function getCurrentContext(path) {
+	if (!path.startsWith("/docs")) return void 0;
+	const match = path.match(/^\/docs\/([^/]+)/);
+	return match ? match[1] : void 0;
+}
+function getContextRoute(contextPath, routeList) {
+	return routeList.find((route) => {
+		return route.href.replace(/^\/+|\/+$/, "") === contextPath;
+	});
+}
+function Menu({ onNavigate, className = "", pathname, routes = [] }) {
+	const menuRoutes = routes;
+	const [currentPath] = useState(() => pathname || (typeof window !== "undefined" ? window.location.pathname : "/docs"));
+	if (!currentPath.startsWith("/docs")) return null;
+	const mode = config.sidebar?.context || "dropdown";
+	const navProps = {
+		"aria-label": "Documentation navigation",
+		className: cn("transition-all duration-200", className)
+	};
+	const renderBorderItem = (item, parentRouteHref, key) => {
+		const fullHref = `/docs${parentRouteHref}${item.href}`;
+		const isActive = currentPath === fullHref || currentPath === `${fullHref}.html`;
+		return /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx("div", {
+			className: cn("-ml-[14px] border-l-2", isActive ? "border-primary" : "border-transparent"),
+			children: /* @__PURE__ */ jsx("div", {
+				className: "pl-3",
+				children: /* @__PURE__ */ jsx(Sublink, {
+					...item,
+					href: item.href,
+					level: 0,
+					onNavigate,
+					parentHref: `/docs${parentRouteHref}`
+				})
+			})
+		}) }, key);
+	};
+	const sharedUlClasses = "border-base-300 flex flex-col gap-0.5 border-l-2 pb-0.5 pl-3 pt-0.5";
+	if (mode === "separator") {
+		const contextRoutes = menuRoutes.filter((r) => r.context);
+		if (contextRoutes.length === 0) return /* @__PURE__ */ jsx(GroupAccordionProvider, { children: /* @__PURE__ */ jsx("nav", {
+			...navProps,
+			children: /* @__PURE__ */ jsx("ul", {
+				className: sharedUlClasses,
+				children: menuRoutes.map((route) => renderBorderItem(route, "", route.href))
+			})
+		}) });
+		return /* @__PURE__ */ jsx(GroupAccordionProvider, { children: /* @__PURE__ */ jsx("nav", {
+			...navProps,
+			children: contextRoutes.map((route, i) => /* @__PURE__ */ jsxs("div", {
+				className: i > 0 ? "mt-6 lg:mt-8" : "",
+				children: [/* @__PURE__ */ jsx(SidebarGroupHeader, {
+					icon: route.context?.icon,
+					title: route.context?.title || route.title
+				}), /* @__PURE__ */ jsx("ul", {
+					className: sharedUlClasses,
+					children: route.items?.map((item) => renderBorderItem(item, route.href, item.href))
+				})]
+			}, route.href))
+		}) });
+	}
+	const isDocsRoot = currentPath === "/docs" || currentPath === "/docs/";
+	const currentContext = isDocsRoot ? menuRoutes[0]?.href.replace(/^\/+|\/+$/, "") : getCurrentContext(currentPath);
+	const contextRoute = isDocsRoot && menuRoutes[0] ? currentContext ? getContextRoute(currentContext, menuRoutes) : menuRoutes[0] : currentContext ? getContextRoute(currentContext, menuRoutes) : void 0;
+	if (!contextRoute) return null;
+	return /* @__PURE__ */ jsx(GroupAccordionProvider, { children: /* @__PURE__ */ jsx("nav", {
+		...navProps,
+		children: /* @__PURE__ */ jsx("ul", {
+			className: "flex flex-col gap-0.5 py-4",
+			children: /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx(Sublink, {
+				...contextRoute,
+				href: contextRoute.href,
+				level: 0,
+				onNavigate,
+				parentHref: "/docs"
+			}) }, contextRoute.title)
+		})
+	}) });
+}
+//#endregion
+//#region .docu/components/DocsLayout.tsx
+var docuConfig = loadDocuConfig();
+function DocsLayout({ children, repoUrl, pathname = "/docs" }) {
+	return React.createElement("div", { className: "docs-layout flex flex-col min-h-screen w-full" }, React.createElement("div", { className: "flex flex-1 items-start w-full" }, React.createElement("aside", {
+		id: "sidebar-island",
+		className: "sticky top-0 hidden h-screen w-[280px] shrink-0 flex-col lg:flex border-r border-base-200 bg-base-100",
+		"data-tocs": "[]",
+		"data-title": "",
+		"data-repo": repoUrl || ""
+	}, React.createElement("div", { className: "flex h-full flex-col overflow-y-auto px-4" }, React.createElement(Menu, {
+		pathname,
+		routes: docuConfig.routes || []
+	}))), React.createElement("main", { className: "flex-1 min-w-0 min-h-screen flex flex-col" }, React.createElement("div", { className: "hidden lg:flex items-center justify-end gap-6 h-14 px-8" }, React.createElement("nav", { className: "flex items-center gap-6 text-sm font-medium text-base-content/80" }, ...(docuConfig.navbar?.menu || []).map((item) => {
+		const isExternal = /^https?:\/\//.test(item.href);
+		const isDocsActive = item.href === "/docs";
+		return React.createElement("a", {
+			key: item.title,
+			href: item.href,
+			className: `flex items-center gap-1 hover:text-base-content transition-colors${isDocsActive ? " text-primary font-semibold" : ""}`,
+			...isExternal ? {
+				target: "_blank",
+				rel: "noopener noreferrer"
+			} : {}
+		}, item.title, isExternal ? React.createElement("svg", {
+			xmlns: "http://www.w3.org/2000/svg",
+			width: "14",
+			height: "14",
+			viewBox: "0 0 24 24",
+			fill: "none",
+			stroke: "currentColor",
+			strokeWidth: "2",
+			strokeLinecap: "round",
+			strokeLinejoin: "round"
+		}, React.createElement("path", { d: "M7 7h10v10" }), React.createElement("path", { d: "M7 17 17 7" })) : null);
+	}))), React.createElement("div", { className: "flex-1 w-full" }, children))));
+}
+//#endregion
+//#region .docu/node/escapeHtml.ts
+var ESCAPE_RE = /[&<>"']/g;
+var ESCAPE_MAP = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#x27;"
+};
+/**
+* Runtime-neutral HTML escaping — same character set as `Bun.escapeHTML`
+* (& < > " '). Used by the shared HTML shell so Node/Deno entries never
+* touch the Bun global.
+*/
+function escapeHtml(input) {
+	return input.replace(ESCAPE_RE, (ch) => ESCAPE_MAP[ch]);
+}
+//#endregion
+//#region .docu/node/html.shared.ts
+/**
+* Runtime-neutral HTML shell — identical templates to `html.ts` (Bun-only,
+* protected) but escaping via the pure `escapeHtml()` so it runs on
+* Node.js and Deno as well as Bun. Shared modules (`server-routes.ts`) and
+* the non-Bun entries import from here; `build.ts`/`server.ts` keep using
+* `html.ts` untouched.
+*/
+function htmlShell(opts) {
+	const { title, description, body, favicon, css, js, nonce, csp, extraScripts, themeCss, depth = 0, headExtra, bodyExtra, absoluteAssets = false } = opts;
+	const nonceAttr = nonce ? ` nonce="${escapeHtml(nonce)}"` : "";
+	const themeStyle = themeCss ? `\n  <style${nonceAttr}>${escapeHtml(themeCss)}</style>` : "";
+	const headInjection = headExtra?.length ? `\n  ${headExtra.join("\n  ")}` : "";
+	const bodyInjection = bodyExtra?.length ? `\n  ${bodyExtra.join("\n  ")}` : "";
+	const depthPrefix = depth === 0 ? "" : "../".repeat(depth);
+	const assetPrefix = absoluteAssets ? "/assets/" : depthPrefix + "assets/";
+	const resolvePath = (path) => absoluteAssets ? path : path.startsWith("/") ? depthPrefix + path.slice(1) : path;
+	let seoTags = "";
+	if (opts.seo) {
+		const s = opts.seo;
+		const e = escapeHtml;
+		seoTags = `\n  <meta property="og:title" content="${e(title)}" />\n  <meta property="og:description" content="${e(description)}" />\n  <meta property="og:url" content="${e(s.url)}" />\n  <meta property="og:type" content="website" />\n  <meta property="og:site_name" content="${e(s.siteName)}" />\n  <meta name="twitter:card" content="summary_large_image" />\n  <link rel="canonical" href="${e(s.url)}" />`;
+		if (s.image) seoTags += `\n  <meta property="og:image" content="${e(s.image)}" />`;
+	}
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(title)}</title>
+  <meta name="description" content="${escapeHtml(description)}">
+  ${favicon ? `<link rel="icon" type="image/x-icon" href="${escapeHtml(resolvePath(favicon))}">` : ""}${themeStyle}
+  <link rel="preload" href="${escapeHtml(assetPrefix + css)}" as="style">
+  <link rel="stylesheet" href="${escapeHtml(assetPrefix + css)}">
+  ${csp ? `<meta http-equiv="Content-Security-Policy" content="${escapeHtml(csp)}">` : ""}
+  ${seoTags}
+  <script${nonceAttr}>try{if(localStorage.getItem("theme")==="dark")document.documentElement.classList.add("dark")}catch(e){}<\/script>${headInjection}
+</head>
+<body>
+  <div id="root">${body}</div>
+  <link rel="modulepreload" href="${escapeHtml(assetPrefix + js)}">
+  <script type="module"${nonceAttr} src="${escapeHtml(assetPrefix + js)}"><\/script>${extraScripts ? `\n  ${extraScripts}` : ""}${bodyInjection}
+</body>
+</html>`;
+}
+function errorHtml(message, stack) {
+	const msg = escapeHtml(message || "Unknown error");
+	const st = escapeHtml(stack || "");
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>Server Error</title>
+  <style>
+    *{margin:0;padding:0;box-sizing:border-box}
+    body{padding:2rem;font-family:ui-monospace,monospace;background:#1a1a2e;color:#e0e0e0}
+    h1{color:#ff6b6b;font-size:1.5rem;margin-bottom:1rem}
+    pre{background:#0d0d1a;border:1px solid #333;border-radius:8px;padding:1.5rem;overflow-x:auto;font-size:14px;line-height:1.6;white-space:pre-wrap;word-break:break-word}
+    .msg{color:#ff6b6b;font-weight:bold}
+  </style>
+</head>
+  <body>
+  <h1>🔥 Server Error</h1>
+    <pre><span class="msg">${msg}</span>${st ? `\n\n${st}` : ""}</pre>
+  </body>
+</html>`;
+}
+function hmrScript(nonce) {
+	return `<script nonce="${escapeHtml(nonce)}">
+(function(){
+  const es = new EventSource("/__hmr");
+  es.onmessage = function(e) {
+    if (e.data === "reload") window.location.reload();
+  };
+  es.onerror = function() { es.close(); setTimeout(() => { window.location.reload(); }, 2000); };
+})();
+<\/script>`;
+}
+//#endregion
+export { hashMdxSources as C, loadPlugins as D, BuildPluginBuilder as E, atomicWriteFile as S, runtimeStamp as T, getPageStripped as _, IndexPage as a, buildClientBundle as b, captureException as c, clearDerivedPageCaches as d, compileMdx as f, getPageFrontmatter as g, getPageContent as h, DocsLayout as i, initSentry as l, frontmatterField as m, hmrScript as n, NotFoundPage as o, compileMdxModule as p, htmlShell as r, DocsPage as s, errorHtml as t, generateSearchIndex as u, registerPageContent as v, hookMemoryPressure as w, computeInlineThemeCss as x, getGitLastModifiedBatch as y };
+
+//# sourceMappingURL=html.shared-FwgbE1WG.js.map