@clarify-labs/cli 0.1.0

package/output/plugin-BUWojlPv.js

@@ -0,0 +1,1277 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import mdxPlugin from "@mdx-js/rollup";
+import tailwindcss from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react";
+import GithubSlugger, { slug } from "github-slugger";
+import { toString } from "mdast-util-to-string";
+import remarkGfm from "remark-gfm";
+import shiki from "shiki";
+import { visit } from "unist-util-visit";
+import { remark } from "remark";
+import matter from "gray-matter";
+import SwaggerParser from "@apidevtools/swagger-parser";
+import { z } from "zod";
+import { tmpdir } from "node:os";
+import { pathToFileURL } from "node:url";
+import { build, loadConfigFromFile } from "vite";
+import { createRequire } from "node:module";
+//#region source/core/utils.ts
+function escapeHtml(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+//#endregion
+//#region source/parsers/mdx.ts
+function getLanguage(className) {
+	return (Array.isArray(className) ? className : typeof className === "string" ? className.split(/\s+/) : []).find((item) => typeof item === "string" && item.startsWith("language-"))?.replace(/^language-/, "") || "txt";
+}
+function getTextContent(node) {
+	if (!node) return "";
+	if (typeof node.value === "string") return node.value;
+	return node.children?.map(getTextContent).join("") ?? "";
+}
+function renderPlainCode(code) {
+	return code.split("\n").map((line) => `<span>${escapeHtml(line)}</span>`).join("\n");
+}
+var highlighter;
+async function getHighlighter() {
+	highlighter = highlighter ?? await shiki.getHighlighter({ theme: "css-variables" });
+	return highlighter;
+}
+function rehypeParseCodeBlocks() {
+	return (tree) => {
+		visit(tree, "element", (node, _nodeIndex, parentNode) => {
+			if (node.tagName !== "code" || !parentNode) return;
+			parentNode.properties = parentNode.properties ?? {};
+			node.properties = node.properties ?? {};
+			const language = getLanguage(node.properties.className);
+			parentNode.properties.language = language;
+			node.properties.language = language;
+		});
+	};
+}
+function rehypeShiki() {
+	return async (tree) => {
+		const shikiHighlighter = await getHighlighter();
+		visit(tree, "element", (node) => {
+			if (node.tagName !== "pre") return;
+			const codeNode = node.children?.[0];
+			if (codeNode?.tagName !== "code") return;
+			node.properties = node.properties ?? {};
+			codeNode.properties = codeNode.properties ?? {};
+			const code = getTextContent(codeNode);
+			const language = typeof node.properties.language === "string" ? node.properties.language : getLanguage(codeNode.properties.className);
+			node.properties.code = code;
+			codeNode.properties.code = code;
+			codeNode.properties.language = language;
+			let highlighted = renderPlainCode(code);
+			if (language && language !== "txt") try {
+				const tokens = shikiHighlighter.codeToThemedTokens(code, language);
+				highlighted = shiki.renderToHtml(tokens, { elements: {
+					pre: ({ children }) => children,
+					code: ({ children }) => children,
+					line: ({ children }) => `<span>${children}</span>`
+				} });
+			} catch {
+				highlighted = renderPlainCode(code);
+			}
+			codeNode.children = [{
+				type: "text",
+				value: highlighted
+			}];
+		});
+	};
+}
+function rehypeSlugSections() {
+	return (tree) => {
+		const slugger = new GithubSlugger();
+		visit(tree, "element", (node) => {
+			if (node.tagName !== "h2" && node.tagName !== "h3") return;
+			node.properties = node.properties ?? {};
+			if (node.properties.id) return;
+			node.properties.id = slugger.slug(toString(node));
+		});
+	};
+}
+var remarkPlugins = [remarkGfm];
+var rehypePlugins = [
+	rehypeSlugSections,
+	rehypeParseCodeBlocks,
+	rehypeShiki
+];
+//#endregion
+//#region source/parsers/frontmatter.ts
+/**
+* 从 MDX 文件内容中提取 frontmatter。
+* 使用 gray-matter 支持 YAML frontmatter 的标准语法和类型解析。
+*/
+function extractFrontmatter(content) {
+	return matter(content).data;
+}
+//#endregion
+//#region source/parsers/routes.ts
+function kebabToTitle$1(str) {
+	return str.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function parseMdxTree(content) {
+	return remark.parse(content);
+}
+/** 从内容中提取第一个 H1 标题 */
+function extractH1(content) {
+	const tree = parseMdxTree(content);
+	let title = "";
+	visit(tree, "heading", (node) => {
+		if (!title && node.depth === 1) title = toString(node);
+	});
+	return title;
+}
+/** 从 MDX/Markdown 内容中提取 H2/H3 章节 */
+function extractMdxSections(content) {
+	const sections = [];
+	const slugger = new GithubSlugger();
+	visit(parseMdxTree(content), "heading", (node) => {
+		if (node.depth !== 2 && node.depth !== 3) return;
+		const title = toString(node);
+		sections.push({
+			id: slugger.slug(title),
+			title,
+			level: node.depth
+		});
+	});
+	return sections;
+}
+function navigationSections(sections) {
+	return sections.map((s) => ({
+		id: s.id,
+		title: s.title,
+		badge: s.badge,
+		tags: s.tags
+	}));
+}
+function normalizePath(path) {
+	const clean = "/" + path.replace(/^\/+|\/+$/g, "");
+	return clean === "/" ? "/" : clean.replace(/\/+/g, "/");
+}
+function basePathFromRef(ref) {
+	const withoutExtension = ref.replace(/\.mdx?$/, "").replace(/\.openapi\.(json|yaml|yml)$/, "");
+	return normalizePath(withoutExtension === "index" ? "/" : withoutExtension.replace(/\/index$/, ""));
+}
+function routePathFromRef(ref) {
+	return basePathFromRef(ref);
+}
+function virtualModuleIdFromRef(ref) {
+	return "virtual:clarify-page/" + ref.replace(/\.mdx?$/, "").replace(/\.openapi\.(json|yaml|yml)$/, "").replace(/\/+/g, "/");
+}
+function localizedRoutePath(basePath, locale, i18n) {
+	const normalizedBasePath = normalizePath(basePath);
+	if (locale === i18n.defaultLocale) return normalizedBasePath;
+	const prefix = normalizePath(locale);
+	return normalizedBasePath === "/" ? prefix : normalizePath(`${prefix}${normalizedBasePath}`);
+}
+function resolveLocalizedText(text, locale, fallbackLocale) {
+	if (typeof text === "string" || text === void 0) return text;
+	return text[locale] ?? (fallbackLocale ? text[fallbackLocale] : void 0) ?? Object.values(text)[0];
+}
+function findContentRoutes(dir, base = dir) {
+	const routes = [];
+	if (!existsSync(dir)) return routes;
+	const entries = readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) routes.push(...findContentRoutes(fullPath, base));
+		else if (entry.isFile() && /\.mdx?$/.test(entry.name)) {
+			const relativePath = relative(base, fullPath);
+			const pathParts = relativePath.replace(/\.mdx?$/, "").split("/");
+			const cleanPath = ("/" + pathParts.map((p) => p === "index" ? "" : p).filter(Boolean).join("/")).replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+			const content = readFileSync(fullPath, "utf-8");
+			const frontmatter = extractFrontmatter(content);
+			let title = typeof frontmatter.title === "string" ? frontmatter.title : "";
+			if (!title) {
+				const lastPart = pathParts[pathParts.length - 1] ?? "";
+				title = kebabToTitle$1(lastPart === "index" ? pathParts.length >= 2 ? pathParts[pathParts.length - 2] : extractH1(content) : lastPart) || "Untitled";
+			}
+			routes.push({
+				path: cleanPath,
+				basePath: cleanPath,
+				filePath: fullPath,
+				virtualModuleId: "virtual:clarify-page/" + relativePath.replace(/\.mdx?$/, "").replace(/\/+/g, "/"),
+				title,
+				kind: "mdx",
+				sections: extractMdxSections(content)
+			});
+		}
+	}
+	return routes;
+}
+function buildNavigation(routes) {
+	const root = [];
+	for (const route of routes) {
+		if (route.path === "/") continue;
+		const parts = route.path.replace(/^\//, "").split("/");
+		let current = root;
+		for (let i = 0; i < parts.length; i++) {
+			const pathSoFar = "/" + parts.slice(0, i + 1).join("/");
+			let node = current.find((n) => n.path === pathSoFar);
+			if (!node) {
+				node = {
+					path: pathSoFar,
+					title: i === parts.length - 1 ? route.title : kebabToTitle$1(parts[i]),
+					children: []
+				};
+				current.push(node);
+			}
+			if (i === parts.length - 1 && route.sections) node.sections = navigationSections(route.sections);
+			if (i < parts.length - 1) {
+				node.children = node.children ?? [];
+				current = node.children;
+			}
+		}
+	}
+	return root;
+}
+function resolvePageItem(item) {
+	if (typeof item === "string") return { pageRef: item };
+	if ("openapi" in item) return {
+		openapiRef: item.openapi,
+		title: item.title,
+		icon: item.icon
+	};
+	return {
+		pageRef: item.page,
+		redirect: item.redirect,
+		title: item.title,
+		icon: item.icon
+	};
+}
+function buildNavigationFromConfig(routes, config) {
+	const routeMap = new Map(routes.map((r) => [r.path, r]));
+	return config.map((group) => {
+		const children = group.pages.map((item) => {
+			const { pageRef, openapiRef, redirect, title, icon } = resolvePageItem(item);
+			if (openapiRef) {
+				const path = "/" + openapiRef.replace(/\.openapi\.(json|yaml|yml)$/, "");
+				const route = routeMap.get(path);
+				return {
+					path,
+					title: resolveLocalizedText(title, "", "") ?? route?.title ?? kebabToTitle$1(path.split("/").pop() ?? openapiRef),
+					icon,
+					sections: route?.sections ? navigationSections(route.sections) : void 0
+				};
+			}
+			const ref = pageRef ?? "";
+			const path = ref === "index" ? "/" : "/" + ref;
+			const route = routeMap.get(path);
+			return {
+				path: redirect ? redirect : path,
+				title: resolveLocalizedText(title, "", "") ?? route?.title ?? kebabToTitle$1(path.split("/").pop() ?? ref),
+				icon,
+				sections: route?.sections ? navigationSections(route.sections) : void 0
+			};
+		});
+		return {
+			path: children[0]?.path ?? "/",
+			title: resolveLocalizedText(group.group, "", "") ?? "",
+			icon: group.icon,
+			children
+		};
+	});
+}
+function localizeNavigationPaths(nodes, locale, i18n) {
+	return nodes.map((node) => ({
+		...node,
+		path: localizedRoutePath(node.path, locale, i18n),
+		children: node.children ? localizeNavigationPaths(node.children, locale, i18n) : void 0
+	}));
+}
+function buildLocalizedNavigation(routes, config, i18n) {
+	if (!i18n) return void 0;
+	const result = {};
+	for (const locale of i18n.locales) {
+		const localeRoutes = routes.filter((route) => route.locale === locale.code);
+		if (!config || config === "FileTree") {
+			const baseNavigation = buildNavigation(localeRoutes.map((route) => ({
+				...route,
+				path: route.basePath ?? route.path
+			})));
+			result[locale.code] = localizeNavigationPaths(baseNavigation, locale.code, i18n);
+			continue;
+		}
+		const routeMap = new Map(localeRoutes.map((route) => [route.basePath ?? route.path, route]));
+		result[locale.code] = config.map((group) => {
+			const children = group.pages.map((item) => {
+				const { pageRef, openapiRef, redirect, title, icon } = resolvePageItem(item);
+				const ref = openapiRef ?? pageRef ?? "";
+				const basePath = basePathFromRef(ref);
+				const route = routeMap.get(basePath);
+				const path = route?.path ?? localizedRoutePath(basePath, locale.code, i18n);
+				return {
+					path: (redirect ? localizedRoutePath(basePathFromRef(redirect), locale.code, i18n) : void 0) ?? path,
+					title: resolveLocalizedText(title, locale.code, i18n.defaultLocale) ?? route?.title ?? kebabToTitle$1(basePath.split("/").pop() ?? ref),
+					icon,
+					sections: route?.sections ? navigationSections(route.sections) : void 0
+				};
+			});
+			return {
+				path: children[0]?.path ?? localizedRoutePath("/", locale.code, i18n),
+				title: resolveLocalizedText(group.group, locale.code, i18n.defaultLocale) ?? "",
+				icon: group.icon,
+				children
+			};
+		});
+	}
+	return result;
+}
+//#endregion
+//#region source/plugins/content-artifacts/raw-content.ts
+function normalizeBasePath(basePath) {
+	if (!basePath || basePath === "/") return "";
+	return "/" + basePath.replace(/^\/+|\/+$/g, "");
+}
+function routeToMarkdownUrl(routePath) {
+	return `${routePath === "/" ? "/index" : routePath.replace(/\/$/, "")}.md`;
+}
+function routeToOpenAPIUrl(routePath, filePath) {
+	const extension = extname(filePath).toLowerCase() || ".json";
+	return `${routePath === "/" ? "/index" : routePath.replace(/\/$/, "")}.openapi${extension}`;
+}
+function enrichRoutesWithRawContent(routes) {
+	for (const route of routes) route.rawContentUrl = route.kind === "openapi" ? routeToOpenAPIUrl(route.path, route.filePath) : routeToMarkdownUrl(route.path);
+}
+function readRawContent(route) {
+	return readFileSync(route.filePath, "utf-8");
+}
+function writeRawContentFiles(routes, outputDirectory) {
+	for (const route of routes) {
+		if (!route.rawContentUrl) continue;
+		const outFile = join(outputDirectory, route.rawContentUrl.replace(/^\//, ""));
+		mkdirSync(dirname(outFile), { recursive: true });
+		writeFileSync(outFile, readRawContent(route), "utf-8");
+	}
+}
+function createLlmsTxt(routes, projectConfig) {
+	const basePath = normalizeBasePath(projectConfig.routePrefix);
+	const lines = [`# ${projectConfig.title}`, ""];
+	if (projectConfig.description) lines.push(`> ${projectConfig.description}`, "");
+	lines.push("## Docs");
+	for (const route of routes.filter((route) => route.kind === "mdx")) {
+		if (!route.rawContentUrl) continue;
+		lines.push(`- [${route.title}](${basePath}${route.rawContentUrl})`);
+	}
+	const openApiRoutes = routes.filter((route) => route.kind === "openapi");
+	if (openApiRoutes.length > 0) {
+		lines.push("", "## OpenAPI");
+		for (const route of openApiRoutes) {
+			if (!route.rawContentUrl) continue;
+			lines.push(`- [${route.title}](${basePath}${route.rawContentUrl})`);
+		}
+	}
+	return `${lines.join("\n")}\n`;
+}
+function writeLlmsTxt(routes, projectConfig, outputDirectory) {
+	mkdirSync(outputDirectory, { recursive: true });
+	writeFileSync(join(outputDirectory, "llms.txt"), createLlmsTxt(routes, projectConfig), "utf-8");
+}
+//#endregion
+//#region source/plugins/content-artifacts/server.ts
+function normalizeRoutePrefix(routePrefix) {
+	if (!routePrefix || routePrefix === "/") return "";
+	return `/${routePrefix.replace(/^\/+|\/+$/g, "")}`;
+}
+function resolveContentArtifactPath(url, projectConfig) {
+	const requestPath = url?.split("?")[0] ?? "";
+	const basePath = normalizeRoutePrefix(projectConfig.routePrefix);
+	return basePath && requestPath.startsWith(basePath) ? requestPath.slice(basePath.length) || "/" : requestPath;
+}
+function resolveRawContentType(route) {
+	if (route.kind === "openapi" && /\.ya?ml$/i.test(route.rawContentUrl ?? "")) return "text/yaml; charset=utf-8";
+	return route.kind === "openapi" ? "application/json; charset=utf-8" : "text/markdown; charset=utf-8";
+}
+function serveContentArtifacts(req, res, projectConfig, routes) {
+	const contentPath = resolveContentArtifactPath(req.url, projectConfig);
+	if (contentPath === "/llms.txt") {
+		res.statusCode = 200;
+		res.setHeader("Content-Type", "text/plain; charset=utf-8");
+		res.end(createLlmsTxt(routes, projectConfig));
+		return true;
+	}
+	const route = routes.find((route) => route.rawContentUrl === contentPath);
+	if (!route) return false;
+	res.statusCode = 200;
+	res.setHeader("Content-Type", resolveRawContentType(route));
+	res.end(readRawContent(route));
+	return true;
+}
+//#endregion
+//#region source/plugins/content-artifacts/index.ts
+function createContentArtifactsPlugin() {
+	return {
+		name: "clarify:content-artifacts",
+		hooks: {
+			"routes:resolved": (input) => {
+				enrichRoutesWithRawContent(input.routes);
+				return input;
+			},
+			"dev:configureServer": (server, ctx) => {
+				server.middlewares.use((req, res, next) => {
+					if (serveContentArtifacts(req, res, ctx.projectConfig, ctx.routes)) return;
+					next();
+				});
+			},
+			"build:done": (ctx) => {
+				const outputDirectory = ctx.generateOptions.outputDirectory;
+				if (!outputDirectory) return;
+				writeRawContentFiles(ctx.routes, outputDirectory);
+				writeLlmsTxt(ctx.routes, ctx.projectConfig, outputDirectory);
+			}
+		}
+	};
+}
+//#endregion
+//#region source/plugins/html-shell/index.ts
+var THEME_BOOTSTRAP_SCRIPT = `(function(){try{var e=localStorage.getItem('clarify:theme');var t=e==='dark'||e==='light'||e==='system'?e:'system';var r=t==='system'?window.matchMedia('(prefers-color-scheme: dark)').matches:t==='dark';document.documentElement.classList.toggle('dark',r);document.documentElement.style.colorScheme=r?'dark':'light'}catch(e){}})();`;
+var REL_ICON_RE = /<link\s+[^>]*rel=["'][^"']*\bicon\b[^"']*["'][^>]*>/i;
+function inferIconType(href) {
+	const path = href.split(/[?#]/, 1)[0]?.toLowerCase() ?? href.toLowerCase();
+	if (path.endsWith(".svg")) return "image/svg+xml";
+	if (path.endsWith(".png")) return "image/png";
+	if (path.endsWith(".ico")) return "image/x-icon";
+	if (path.endsWith(".webp")) return "image/webp";
+}
+function createIconTag(href, media) {
+	return {
+		tag: "link",
+		attrs: {
+			rel: "icon",
+			...inferIconType(href) ? { type: inferIconType(href) } : {},
+			href,
+			...media ? { media } : {}
+		},
+		injectTo: "head"
+	};
+}
+function createIconTags(icon) {
+	if (!icon) return [];
+	if (typeof icon === "string") return [createIconTag(icon)];
+	const lightIcon = icon.light ?? icon.dark;
+	const darkIcon = icon.dark ?? icon.light;
+	if (!lightIcon || !darkIcon) return [];
+	if (lightIcon === darkIcon) return [createIconTag(lightIcon)];
+	return [createIconTag(lightIcon, "(prefers-color-scheme: light)"), createIconTag(darkIcon, "(prefers-color-scheme: dark)")];
+}
+function createHtmlShellPlugin() {
+	return {
+		name: "clarify:html-shell",
+		hooks: { "html:transform": (input, ctx) => ({
+			html: input.html,
+			tags: [
+				...input.tags,
+				...REL_ICON_RE.test(input.html) ? [] : createIconTags(ctx.projectConfig.favicon ?? ctx.projectConfig.logo),
+				{
+					tag: "script",
+					children: THEME_BOOTSTRAP_SCRIPT,
+					injectTo: "head-prepend"
+				},
+				{
+					tag: "script",
+					attrs: {
+						type: "module",
+						src: input.clientEntryId
+					},
+					injectTo: "body"
+				}
+			],
+			clientEntryId: input.clientEntryId,
+			dev: input.dev
+		}) }
+	};
+}
+//#endregion
+//#region source/plugins/openapi/parser.ts
+var OPENAPI_HTTP_METHODS = [
+	"get",
+	"put",
+	"post",
+	"delete",
+	"options",
+	"head",
+	"patch",
+	"trace"
+];
+function kebabToTitle(str) {
+	return str.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function findOpenAPIRoutes(dir, base = dir) {
+	const routes = [];
+	if (!existsSync(dir)) return routes;
+	const entries = readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			routes.push(...findOpenAPIRoutes(fullPath, base));
+			continue;
+		}
+		if (!entry.isFile() || !/\.openapi\.(json|yaml|yml)$/.test(entry.name)) continue;
+		const ref = relative(base, fullPath);
+		const cleanPath = routePathFromRef(ref);
+		routes.push({
+			path: cleanPath,
+			basePath: cleanPath,
+			filePath: fullPath,
+			virtualModuleId: virtualModuleIdFromRef(ref),
+			title: kebabToTitle(cleanPath.split("/").pop() ?? "API"),
+			kind: "openapi"
+		});
+	}
+	return routes;
+}
+/** Extract endpoint operations from an OpenAPI spec as page sections. */
+function extractOpenAPISections(spec) {
+	const sections = [];
+	const paths = spec.paths ?? {};
+	for (const [path, pathItem] of Object.entries(paths)) {
+		if (!pathItem) continue;
+		for (const method of OPENAPI_HTTP_METHODS) {
+			const op = pathItem[method];
+			if (!op) continue;
+			const title = op.summary ?? `${method.toUpperCase()} ${path}`;
+			sections.push({
+				id: slug(`${method} ${path}`),
+				title,
+				level: 2,
+				badge: method.toUpperCase()
+			});
+		}
+	}
+	return sections;
+}
+async function readOpenAPISpec(filePath) {
+	try {
+		return await SwaggerParser.dereference(filePath);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region source/plugins/openapi/virtual-modules.ts
+var openApiRegistryModuleId = "virtual:clarify-openapi-registry";
+function generateOpenAPIRegistryModule(openApis) {
+	return `export const openApis = ${JSON.stringify(openApis)};`;
+}
+function generateOpenAPIModule(spec) {
+	return `import { createElement } from 'react';
+import { OpenApiPage } from '@clarify-labs/renderer';
+const spec = ${JSON.stringify(spec)};
+export default function OpenApiRoutePage() {
+  return createElement(OpenApiPage, { spec });
+}`;
+}
+//#endregion
+//#region source/plugins/openapi/index.ts
+function createOpenAPIPlugin() {
+	const specs = {};
+	return {
+		name: "clarify:openapi",
+		hooks: {
+			"routes:discover": (input) => ({
+				...input,
+				routes: [...input.routes, ...findOpenAPIRoutes(input.contentRoot)]
+			}),
+			"routes:discovered": async (routes) => {
+				for (const key of Object.keys(specs)) delete specs[key];
+				for (const route of routes.filter((route) => route.kind === "openapi")) {
+					const spec = await readOpenAPISpec(route.filePath);
+					if (!spec) throw new Error(`Failed to parse OpenAPI spec: ${route.filePath}`);
+					specs[route.virtualModuleId] = spec;
+					specs[`virtual:clarify-page/${route.path.replace(/^\//, "")}`] = spec;
+					route.title = spec.info?.title ?? route.title;
+					route.sections = extractOpenAPISections(spec);
+				}
+				return routes;
+			},
+			"modules:before": (modules) => {
+				modules.set(openApiRegistryModuleId, generateOpenAPIRegistryModule(specs));
+				for (const [moduleId, spec] of Object.entries(specs)) modules.set(moduleId, generateOpenAPIModule(spec));
+				return modules;
+			}
+		}
+	};
+}
+//#endregion
+//#region source/core/config-schema.ts
+var clarifyLogoConfigSchema = z.union([z.string(), z.object({
+	light: z.string().optional(),
+	dark: z.string().optional()
+})]);
+var clarifyFaviconConfigSchema = z.union([z.string(), z.object({
+	light: z.string().optional(),
+	dark: z.string().optional()
+})]);
+var clarifyLocalizedTextSchema = z.union([z.string(), z.record(z.string(), z.string())]);
+var clarifyLocaleConfigSchema = z.object({
+	code: z.string(),
+	label: z.string(),
+	dir: z.union([z.literal("ltr"), z.literal("rtl")]).optional()
+});
+var clarifyI18nConfigSchema = z.object({
+	defaultLocale: z.string().optional(),
+	missing: z.union([
+		z.literal("fallback"),
+		z.literal("404"),
+		z.literal("hide")
+	]).optional(),
+	locales: z.array(clarifyLocaleConfigSchema).min(1)
+}).superRefine((config, ctx) => {
+	const localeCodes = /* @__PURE__ */ new Set();
+	for (const [index, locale] of config.locales.entries()) {
+		if (localeCodes.has(locale.code)) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: `Duplicate locale code "${locale.code}"`,
+			path: [
+				"locales",
+				index,
+				"code"
+			]
+		});
+		localeCodes.add(locale.code);
+	}
+	if (config.defaultLocale && !localeCodes.has(config.defaultLocale)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "defaultLocale must be one of i18n.locales",
+		path: ["defaultLocale"]
+	});
+});
+var clarifyNavbarLinkSchema = z.object({
+	label: clarifyLocalizedTextSchema,
+	href: z.string(),
+	external: z.boolean().optional()
+});
+var clarifyBannerConfigSchema = z.object({
+	content: clarifyLocalizedTextSchema,
+	dismissible: z.boolean().optional()
+});
+var clarifyFooterConfigSchema = z.object({
+	links: z.array(clarifyNavbarLinkSchema).optional(),
+	socials: z.record(z.string(), z.string()).optional(),
+	copyright: clarifyLocalizedTextSchema.optional()
+});
+var clarifyPagesItemSchema = z.union([
+	z.string(),
+	z.object({
+		page: z.string(),
+		title: clarifyLocalizedTextSchema.optional(),
+		icon: z.string().optional(),
+		redirect: z.string().optional()
+	}),
+	z.object({
+		openapi: z.string(),
+		icon: z.string().optional(),
+		title: clarifyLocalizedTextSchema.optional()
+	})
+]);
+var clarifyPagesGroupSchema = z.object({
+	group: clarifyLocalizedTextSchema,
+	icon: z.string().optional(),
+	pages: z.array(clarifyPagesItemSchema)
+});
+var clarifyPagesConfigSchema = z.union([z.array(clarifyPagesGroupSchema), z.literal("FileTree")]);
+var clarifyProjectConfigSchema = z.object({
+	title: z.string().optional(),
+	description: z.string().optional(),
+	logo: clarifyLogoConfigSchema.optional(),
+	favicon: clarifyFaviconConfigSchema.optional(),
+	theme: z.object({ primary: z.string().optional() }).optional(),
+	routePrefix: z.string().optional(),
+	navbar: z.object({ links: z.array(clarifyNavbarLinkSchema).optional() }).optional(),
+	banner: clarifyBannerConfigSchema.optional(),
+	footer: clarifyFooterConfigSchema.optional(),
+	i18n: clarifyI18nConfigSchema.optional(),
+	pages: clarifyPagesConfigSchema.optional()
+});
+//#endregion
+//#region source/core/config.ts
+function formatIssuePath(path) {
+	return path.reduce((result, segment) => {
+		if (typeof segment === "number") return `${result}[${segment}]`;
+		const key = String(segment);
+		return result ? `${result}.${key}` : key;
+	}, "");
+}
+function formatProjectConfigError(error) {
+	const issue = error.issues[0];
+	if (!issue) return "[clarify] config is invalid";
+	const path = formatIssuePath(issue.path);
+	if (!path) return `[clarify] config must contain an object: ${issue.message}`;
+	return `[clarify] config field "${path}" is invalid: ${issue.message}`;
+}
+function validateProjectConfig(value) {
+	const result = clarifyProjectConfigSchema.safeParse(value);
+	if (!result.success) throw new Error(formatProjectConfigError(result.error));
+	return result.data;
+}
+function resolveI18nConfig(i18n) {
+	if (!i18n) return void 0;
+	const firstLocale = i18n.locales[0]?.code;
+	const defaultLocale = i18n.defaultLocale ?? firstLocale;
+	if (!defaultLocale) return void 0;
+	return {
+		defaultLocale,
+		missing: i18n.missing ?? "fallback",
+		locales: i18n.locales
+	};
+}
+function resolveProjectConfig(config = {}) {
+	return {
+		title: config.title ?? "Clarify Docs",
+		description: config.description ?? "",
+		logo: config.logo,
+		favicon: config.favicon,
+		routePrefix: config.routePrefix ?? "/",
+		theme: config.theme ?? {},
+		navbar: config.navbar,
+		banner: config.banner,
+		footer: config.footer,
+		i18n: resolveI18nConfig(config.i18n),
+		pages: config.pages
+	};
+}
+//#endregion
+//#region source/core/hooks.ts
+async function runHooks(plugins, hookName, input, ctx) {
+	let result = input;
+	for (const plugin of plugins) {
+		const hook = plugin.hooks[hookName];
+		if (!hook) continue;
+		try {
+			result = await hook(result, ctx);
+		} catch (err) {
+			throw new Error(`[clarify] plugin "${plugin.name}" hook "${hookName}" failed: ${err}`, { cause: err });
+		}
+	}
+	return result;
+}
+async function runDevConfigureServerHooks(plugins, server, ctx) {
+	for (const plugin of plugins) {
+		const hook = plugin.hooks["dev:configureServer"];
+		if (!hook) continue;
+		try {
+			await hook(server, ctx);
+		} catch (err) {
+			throw new Error(`[clarify] plugin "${plugin.name}" hook "dev:configureServer" failed: ${err}`, { cause: err });
+		}
+	}
+}
+async function runBuildDoneHooks(plugins, ctx) {
+	for (const plugin of plugins) {
+		const hook = plugin.hooks["build:done"];
+		if (!hook) continue;
+		try {
+			await hook(ctx);
+		} catch (err) {
+			throw new Error(`[clarify] plugin "${plugin.name}" hook "build:done" failed: ${err}`, { cause: err });
+		}
+	}
+}
+//#endregion
+//#region source/core/options.ts
+function resolveBuildOptions(options = {}) {
+	return {
+		rootDirectory: options.rootDirectory ?? "source",
+		outputDirectory: options.outputDirectory,
+		ssg: { failOnError: options.ssg?.failOnError ?? true }
+	};
+}
+//#endregion
+//#region source/core/runtime-deps.ts
+var requireFromCli = createRequire(import.meta.url);
+function resolveCliDependency(id) {
+	return requireFromCli.resolve(id);
+}
+function resolvePackageExport(packageName, subpath, condition = "import") {
+	const packageJsonPath = requireFromCli.resolve(`${packageName}/package.json`);
+	const packageRoot = dirname(packageJsonPath);
+	const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+	const exportKey = subpath ? `./${subpath}` : ".";
+	const exportEntry = packageJson.exports?.[exportKey];
+	const target = typeof exportEntry === "string" ? exportEntry : exportEntry?.[condition] ?? exportEntry?.default;
+	if (!target) throw new Error(`[clarify] Unable to resolve ${packageName}/${subpath}`);
+	return join(packageRoot, target);
+}
+/**
+* Resolve Clarify's framework/runtime dependencies from the CLI package instead
+* of from the user's documentation project. This keeps content-only projects
+* free from React, renderer, and tsconfig requirements.
+*/
+function createClarifyRuntimeAliases() {
+	return [
+		{
+			find: /^@clarify-labs\/renderer\/style\.css$/,
+			replacement: resolvePackageExport("@clarify-labs/renderer", "style.css")
+		},
+		{
+			find: /^@clarify-labs\/renderer\/client$/,
+			replacement: resolvePackageExport("@clarify-labs/renderer", "client")
+		},
+		{
+			find: /^@clarify-labs\/renderer\/server$/,
+			replacement: resolvePackageExport("@clarify-labs/renderer", "server")
+		},
+		{
+			find: /^@clarify-labs\/renderer$/,
+			replacement: resolvePackageExport("@clarify-labs/renderer", "")
+		},
+		{
+			find: /^react\/jsx-runtime$/,
+			replacement: resolveCliDependency("react/jsx-runtime")
+		},
+		{
+			find: /^react\/jsx-dev-runtime$/,
+			replacement: resolveCliDependency("react/jsx-dev-runtime")
+		},
+		{
+			find: /^react-dom\/client$/,
+			replacement: resolveCliDependency("react-dom/client")
+		},
+		{
+			find: /^react-dom\/server$/,
+			replacement: resolveCliDependency("react-dom/server")
+		},
+		{
+			find: /^react-dom$/,
+			replacement: resolveCliDependency("react-dom")
+		},
+		{
+			find: /^react-router-dom$/,
+			replacement: resolveCliDependency("react-router-dom")
+		},
+		{
+			find: /^react$/,
+			replacement: resolveCliDependency("react")
+		}
+	];
+}
+//#endregion
+//#region source/core/ssg.ts
+function readIndexHtml(outputDirectory) {
+	const indexPath = join(outputDirectory, "index.html");
+	if (!existsSync(indexPath)) return void 0;
+	try {
+		return readFileSync(indexPath, "utf-8");
+	} catch {
+		return;
+	}
+}
+function injectHtmlLocaleAttributes(html, projectConfig, route) {
+	const localeCode = route?.locale ?? projectConfig.i18n?.defaultLocale;
+	if (!localeCode) return html;
+	const dir = (projectConfig.i18n?.locales.find((locale) => locale.code === localeCode))?.dir;
+	return html.replace(/<html\b([^>]*)>/i, (_match, attributes) => {
+		let nextAttributes = attributes.replace(/\s+lang=("[^"]*"|'[^']*'|[^\s>]*)/i, "").replace(/\s+dir=("[^"]*"|'[^']*'|[^\s>]*)/i, "");
+		nextAttributes = `${nextAttributes} lang="${escapeHtml(localeCode)}"`;
+		if (dir) nextAttributes = `${nextAttributes} dir="${escapeHtml(dir)}"`;
+		return `<html${nextAttributes}>`;
+	});
+}
+function injectSSRIntoTemplate(template, appHtml, projectConfig, route) {
+	let html = injectHtmlLocaleAttributes(template, projectConfig, route);
+	html = html.replace(/<title>.*?<\/title>/, `<title>${escapeHtml(projectConfig.title)}</title>`);
+	if (projectConfig.description && !html.includes("name=\"description\"")) {
+		const descriptionMeta = `<meta name="description" content="${escapeHtml(projectConfig.description)}" />`;
+		html = html.replace("</head>", `  ${descriptionMeta}\n  </head>`);
+	}
+	html = html.replace(/<div id="root">[\s\S]*?<\/div>/, `<div id="root">${appHtml}</div>`);
+	return html;
+}
+var SSR_ENTRY_CODE = `import { renderToHTML } from '@clarify-labs/renderer/server';
+import { routes, navigation } from 'virtual:clarify-routes';
+import { config } from 'virtual:clarify-config';
+import { openApis } from 'virtual:clarify-openapi-registry';
+
+export function render(url) {
+  return renderToHTML({ config, routes, navigation, openApis, url });
+}`;
+function createTempEntryFile(content) {
+	const entryPath = join(mkdtempSync(join(tmpdir(), "clarify-ssr-")), "entry-server.ts");
+	writeFileSync(entryPath, content, "utf-8");
+	return entryPath;
+}
+async function buildSSRBundle(root, ssrEntry, ssrOutDir, plugins) {
+	await build({
+		root,
+		configFile: false,
+		resolve: { alias: createClarifyRuntimeAliases() },
+		plugins,
+		build: {
+			ssr: ssrEntry,
+			outDir: ssrOutDir,
+			emptyOutDir: true,
+			rollupOptions: { input: ssrEntry }
+		}
+	});
+}
+async function renderSSGRoutes(routes, projectConfig, outputDirectory, ssrBundlePath, failOnError = true) {
+	const { render } = await import(pathToFileURL(ssrBundlePath).href);
+	const template = readIndexHtml(outputDirectory);
+	if (!template) throw new Error(`[clarify] index.html not found in outputDirectory "${outputDirectory}". Make sure Vite build produces it.`);
+	for (const route of routes) try {
+		const finalHtml = injectSSRIntoTemplate(template, render(route.path), projectConfig, route);
+		const outFile = join(outputDirectory, route.path, "index.html");
+		mkdirSync(dirname(outFile), { recursive: true });
+		writeFileSync(outFile, finalHtml, "utf-8");
+	} catch (err) {
+		console.error(`[clarify] Failed to render route "${route.path}":`, err);
+		if (failOnError) throw err;
+	}
+}
+//#endregion
+//#region source/core/user-config.ts
+function defineConfig(config) {
+	return config;
+}
+var CONFIG_FILENAMES = [
+	"clarify.ts",
+	"clarify.js",
+	"clarify.json"
+];
+function findClarifyConfigFile(root) {
+	for (const filename of CONFIG_FILENAMES) {
+		const filePath = resolve(root, filename);
+		if (existsSync(filePath)) return filePath;
+	}
+}
+function assertConfigObject(config, configFile) {
+	if (!config || typeof config !== "object" || Array.isArray(config)) throw new Error(`[clarify] ${configFile} must export a configuration object`);
+	return config;
+}
+function loadJsonConfig(configFile) {
+	const config = assertConfigObject(JSON.parse(readFileSync(configFile, "utf-8")), configFile);
+	const projectConfig = validateProjectConfig(config);
+	const ssg = config.ssg && typeof config.ssg === "object" && !Array.isArray(config.ssg) ? config.ssg : void 0;
+	return {
+		...projectConfig,
+		...ssg ? { ssg } : {}
+	};
+}
+async function loadClarifyConfig(root, env) {
+	const configFile = findClarifyConfigFile(root);
+	if (!configFile) return {};
+	if (configFile.endsWith(".json")) return loadJsonConfig(configFile);
+	return assertConfigObject((await loadConfigFromFile(env, configFile, root, "silent"))?.config, configFile);
+}
+//#endregion
+//#region source/core/virtual-modules.ts
+var VIRTUAL_CONFIG = "virtual:clarify-config";
+var VIRTUAL_ROUTES = "virtual:clarify-routes";
+var VIRTUAL_OPENAPI_REGISTRY = openApiRegistryModuleId;
+var VIRTUAL_CLIENT_ENTRY = "virtual:clarify-entry-client";
+var RESOLVED_CLIENT_ENTRY = "\0virtual:clarify-entry-client";
+function resolveVirtualId(id) {
+	return "\0" + id;
+}
+function stripVirtualPrefix(id) {
+	return id.startsWith("\0") ? id.slice(1) : id;
+}
+function generateConfigModule(projectConfig, buildOptions) {
+	return `export const config = ${JSON.stringify({
+		...projectConfig,
+		...buildOptions
+	})};`;
+}
+function generateRoutesModule(routes, pagesConfig, resolvedNavigation, projectConfig) {
+	const imports = routes.map((r, i) => `import Page${i} from '${r.virtualModuleId}';`).join("\n");
+	const routesArray = routes.map((r, i) => {
+		const sections = r.sections && r.sections.length > 0 ? `, sections: ${JSON.stringify(r.sections.map((s) => ({
+			id: s.id,
+			title: s.title,
+			badge: s.badge,
+			tags: s.tags
+		})))}` : "";
+		const rawContentUrl = r.rawContentUrl ? `, rawContentUrl: ${JSON.stringify(r.rawContentUrl)}` : "";
+		const basePath = r.basePath ? `, basePath: ${JSON.stringify(r.basePath)}` : "";
+		const locale = r.locale ? `, locale: ${JSON.stringify(r.locale)}` : "";
+		const isFallback = r.isFallback ? ", isFallback: true" : "";
+		const alternates = r.alternates ? `, alternates: ${JSON.stringify(r.alternates)}` : "";
+		return `  { path: ${JSON.stringify(r.path)}, title: ${JSON.stringify(r.title)}, component: Page${i}, kind: '${r.kind}'${basePath}${locale}${isFallback}${alternates}${sections}${rawContentUrl} }`;
+	}).join(",\n");
+	const navigation = resolvedNavigation ?? (projectConfig?.i18n ? buildLocalizedNavigation(routes, pagesConfig, projectConfig.i18n) ?? {} : pagesConfig && pagesConfig !== "FileTree" ? buildNavigationFromConfig(routes, pagesConfig) : buildNavigation(routes));
+	return `${imports}\n\nexport const routes = [\n${routesArray}\n];\n\nexport const navigation = ${JSON.stringify(navigation, null, 2)};\n`;
+}
+function createClientEntryModule() {
+	return `
+import '@clarify-labs/renderer/style.css';
+import { render } from '@clarify-labs/renderer/client';
+import { routes, navigation } from '${VIRTUAL_ROUTES}';
+import { config } from '${VIRTUAL_CONFIG}';
+import { openApis } from '${VIRTUAL_OPENAPI_REGISTRY}';
+render({ config, routes, navigation, openApis });`;
+}
+function buildVirtualModules(args) {
+	const modules = /* @__PURE__ */ new Map();
+	modules.set(VIRTUAL_CONFIG, generateConfigModule(args.projectConfig, args.generateOptions));
+	modules.set(VIRTUAL_ROUTES, generateRoutesModule(args.routes, args.projectConfig.pages, args.navigation, args.projectConfig));
+	modules.set(VIRTUAL_OPENAPI_REGISTRY, "export const openApis = {};");
+	modules.set(VIRTUAL_CLIENT_ENTRY, createClientEntryModule());
+	modules.set(RESOLVED_CLIENT_ENTRY, createClientEntryModule());
+	for (const route of args.routes) {
+		if (route.kind === "openapi") continue;
+		modules.set(route.virtualModuleId, `export { default } from '${route.filePath}';`);
+	}
+	return modules;
+}
+//#endregion
+//#region source/core/plugin.ts
+function loadVirtualModule(id, modules) {
+	const bareId = stripVirtualPrefix(id);
+	return modules.get(bareId) ?? modules.get(id) ?? null;
+}
+function clarifyPlugin(options = {}) {
+	const root = resolve(options.projectRoot ?? process.cwd());
+	let projectConfig = resolveProjectConfig(options);
+	let generateOptions = resolveBuildOptions(options);
+	const contentRoot = join(root, generateOptions.rootDirectory);
+	const configFilePath = findClarifyConfigFile(root);
+	let routes = [];
+	const clarifyPlugins = [
+		createOpenAPIPlugin(),
+		createContentArtifactsPlugin(),
+		createHtmlShellPlugin(),
+		...options.plugins ?? []
+	];
+	const ctx = {
+		projectConfig,
+		generateOptions,
+		routes,
+		navigation: []
+	};
+	let viteConfig;
+	let resolvedNavigation = [];
+	let virtualModules = /* @__PURE__ */ new Map();
+	async function reloadProjectConfig() {
+		const buildOptions = {
+			...await loadClarifyConfig(root, {
+				command: "serve",
+				mode: viteConfig.mode
+			}),
+			projectRoot: options.projectRoot,
+			rootDirectory: options.rootDirectory,
+			outputDirectory: options.outputDirectory
+		};
+		projectConfig = resolveProjectConfig(buildOptions);
+		generateOptions = resolveBuildOptions(buildOptions);
+		ctx.projectConfig = projectConfig;
+		ctx.generateOptions = generateOptions;
+	}
+	function withAlternates(route, routeList, i18n) {
+		const basePath = route.basePath ?? route.path;
+		const routeByLocaleAndBase = new Map(routeList.map((route) => [`${route.locale ?? ""}:${route.basePath ?? route.path}`, route]));
+		const alternates = Object.fromEntries(i18n.locales.flatMap((locale) => {
+			const alternate = routeByLocaleAndBase.get(`${locale.code}:${basePath}`);
+			return alternate ? [[locale.code, alternate.path]] : [];
+		}));
+		return {
+			...route,
+			alternates
+		};
+	}
+	async function discoverRoutesForRoot(routeRoot, locale) {
+		return (await runHooks(clarifyPlugins, "routes:discover", {
+			contentRoot: routeRoot,
+			locale,
+			routes: findContentRoutes(routeRoot)
+		}, ctx)).routes;
+	}
+	async function discoverRoutes() {
+		const i18n = projectConfig.i18n;
+		if (!i18n) return discoverRoutesForRoot(contentRoot);
+		const localizedRoutes = [];
+		for (const locale of i18n.locales) {
+			const discovered = await discoverRoutesForRoot(join(contentRoot, locale.code), locale.code);
+			for (const route of discovered) {
+				const basePath = route.basePath ?? route.path;
+				localizedRoutes.push({
+					...route,
+					path: localizedRoutePath(basePath, locale.code, i18n),
+					basePath,
+					locale: locale.code,
+					virtualModuleId: virtualModuleIdFromRef(relative(contentRoot, route.filePath))
+				});
+			}
+		}
+		if (i18n.missing === "fallback") {
+			const routeByLocaleAndBase = new Map(localizedRoutes.map((route) => [`${route.locale ?? ""}:${route.basePath ?? route.path}`, route]));
+			const defaultRoutes = localizedRoutes.filter((route) => route.locale === i18n.defaultLocale);
+			for (const sourceRoute of defaultRoutes) {
+				const basePath = sourceRoute.basePath ?? sourceRoute.path;
+				for (const locale of i18n.locales) {
+					const key = `${locale.code}:${basePath}`;
+					if (routeByLocaleAndBase.has(key)) continue;
+					localizedRoutes.push({
+						...sourceRoute,
+						path: localizedRoutePath(basePath, locale.code, i18n),
+						locale: locale.code,
+						isFallback: true
+					});
+				}
+			}
+		}
+		return localizedRoutes.map((route) => withAlternates(route, localizedRoutes, i18n));
+	}
+	async function resolveRoutesAndSpecs() {
+		routes = await discoverRoutes();
+		routes = await runHooks(clarifyPlugins, "routes:discovered", routes, ctx);
+		const defaultNavigation = projectConfig.i18n ? buildLocalizedNavigation(routes, projectConfig.pages, projectConfig.i18n) ?? {} : projectConfig.pages && projectConfig.pages !== "FileTree" ? buildNavigationFromConfig(routes, projectConfig.pages) : buildNavigation(routes);
+		const resolved = await runHooks(clarifyPlugins, "routes:resolved", {
+			routes,
+			navigation: defaultNavigation
+		}, ctx);
+		routes = resolved.routes;
+		resolvedNavigation = resolved.navigation;
+		ctx.routes = routes;
+		ctx.navigation = resolvedNavigation;
+	}
+	async function rebuildVirtualModules() {
+		virtualModules = buildVirtualModules({
+			projectConfig,
+			generateOptions,
+			routes,
+			navigation: resolvedNavigation
+		});
+		virtualModules = await runHooks(clarifyPlugins, "modules:before", virtualModules, ctx);
+	}
+	function invalidateVirtualModules(server) {
+		for (const id of virtualModules.keys()) {
+			const moduleNode = server.moduleGraph.getModuleById(resolveVirtualId(id));
+			if (moduleNode) server.moduleGraph.invalidateModule(moduleNode);
+		}
+	}
+	async function refreshDevServer(server) {
+		await resolveRoutesAndSpecs();
+		await rebuildVirtualModules();
+		invalidateVirtualModules(server);
+		server.ws.send({ type: "full-reload" });
+	}
+	function hasContentRouteForFile(filePath) {
+		return routes.some((route) => route.filePath === filePath);
+	}
+	const mdx = mdxPlugin({
+		include: ["**/*.{md,mdx}"],
+		jsxImportSource: "react",
+		providerImportSource: "@clarify-labs/renderer",
+		remarkPlugins,
+		rehypePlugins
+	});
+	return [
+		react(),
+		tailwindcss(),
+		{
+			name: "clarify:core",
+			async config() {
+				await resolveRoutesAndSpecs();
+				return {
+					base: projectConfig.routePrefix,
+					build: {
+						...generateOptions.outputDirectory ? { outDir: generateOptions.outputDirectory } : {},
+						manifest: true
+					}
+				};
+			},
+			configResolved(config) {
+				viteConfig = config;
+				if (!generateOptions.outputDirectory) generateOptions.outputDirectory = config.build.outDir;
+			},
+			async buildStart() {
+				await rebuildVirtualModules();
+			},
+			async handleHotUpdate(ctx) {
+				const changedFile = isAbsolute(ctx.file) ? ctx.file : join(root, ctx.file);
+				if (configFilePath && changedFile === configFilePath) {
+					await reloadProjectConfig();
+					await refreshDevServer(ctx.server);
+					return [];
+				}
+				const relativeContentFile = relative(contentRoot, changedFile);
+				if (!(relativeContentFile && !relativeContentFile.startsWith("..") && !isAbsolute(relativeContentFile)) || !hasContentRouteForFile(changedFile)) return;
+				await refreshDevServer(ctx.server);
+				return [];
+			},
+			resolveId(id) {
+				if (id === "virtual:clarify-entry-client" || id === "\0virtual:clarify-entry-client") return RESOLVED_CLIENT_ENTRY;
+				if (id === "virtual:clarify-config" || id === resolveVirtualId("virtual:clarify-config")) return resolveVirtualId(VIRTUAL_CONFIG);
+				if (id === "virtual:clarify-routes" || id === resolveVirtualId("virtual:clarify-routes")) return resolveVirtualId(VIRTUAL_ROUTES);
+				if (id === VIRTUAL_OPENAPI_REGISTRY || id === resolveVirtualId(VIRTUAL_OPENAPI_REGISTRY)) return resolveVirtualId(VIRTUAL_OPENAPI_REGISTRY);
+				const route = routes.find((r) => r.virtualModuleId === id || r.virtualModuleId === stripVirtualPrefix(id));
+				if (route) return resolveVirtualId(route.virtualModuleId);
+				return null;
+			},
+			load(id) {
+				return loadVirtualModule(id, virtualModules);
+			},
+			async configureServer(server) {
+				server.watcher.add(contentRoot);
+				if (configFilePath) server.watcher.add(configFilePath);
+				const handleContentTreeChange = async (filePath) => {
+					const relativeContentFile = relative(contentRoot, isAbsolute(filePath) ? filePath : join(root, filePath));
+					if (!(relativeContentFile && !relativeContentFile.startsWith("..") && !isAbsolute(relativeContentFile))) return;
+					await refreshDevServer(server);
+				};
+				server.watcher.on("add", handleContentTreeChange);
+				server.watcher.on("unlink", handleContentTreeChange);
+				await runDevConfigureServerHooks(clarifyPlugins, server, ctx);
+			},
+			transformIndexHtml: {
+				order: "pre",
+				async handler(html, transformCtx) {
+					const result = await runHooks(clarifyPlugins, "html:transform", {
+						html,
+						tags: [],
+						clientEntryId: transformCtx.server ? `/@id/${VIRTUAL_CLIENT_ENTRY}` : VIRTUAL_CLIENT_ENTRY,
+						dev: Boolean(transformCtx.server)
+					}, ctx);
+					return {
+						html: result.html,
+						tags: result.tags
+					};
+				}
+			},
+			async closeBundle() {
+				if (process.env.SKIP_CLARIFY_SSG) {
+					await runBuildDoneHooks(clarifyPlugins, ctx);
+					return;
+				}
+				const outputDir = viteConfig.build.outDir;
+				const ssrOutputDir = join(outputDir, ".ssr");
+				let tempEntryPath;
+				try {
+					tempEntryPath = createTempEntryFile(SSR_ENTRY_CODE);
+					await buildSSRBundle(root, tempEntryPath, ssrOutputDir, [{
+						name: "clarify:virtual-ssg",
+						resolveId(id) {
+							if (id === "virtual:clarify-entry-client") return RESOLVED_CLIENT_ENTRY;
+							if (id === "\0virtual:clarify-entry-client") return RESOLVED_CLIENT_ENTRY;
+							if (id === "virtual:clarify-config") return id;
+							if (id === "virtual:clarify-routes") return id;
+							if (id === VIRTUAL_OPENAPI_REGISTRY) return id;
+							if (routes.find((r) => r.virtualModuleId === id)) return id;
+							return null;
+						},
+						load: (id) => loadVirtualModule(id, virtualModules)
+					}, mdx]);
+					const ssrBundlePath = join(ssrOutputDir, "entry-server.js");
+					await renderSSGRoutes(routes, projectConfig, outputDir, ssrBundlePath, generateOptions.ssg.failOnError);
+				} catch (err) {
+					console.error("[clarify] SSG failed:", err);
+					if (generateOptions.ssg.failOnError) throw err;
+				} finally {
+					if (tempEntryPath) try {
+						rmSync(tempEntryPath, { force: true });
+					} catch {}
+				}
+				await runBuildDoneHooks(clarifyPlugins, ctx);
+			}
+		},
+		mdx
+	].flat().filter(Boolean);
+}
+//#endregion
+export { createClarifyRuntimeAliases as i, defineConfig as n, loadClarifyConfig as r, clarifyPlugin as t };
+
+//# sourceMappingURL=plugin-BUWojlPv.js.map