yaakdoc 0.0.0-stage → 0.2.0

package/dist/preview-Ba1BfVZV.js

@@ -0,0 +1,659 @@
+import { a as matchRoute, c as VERSION, h as resolveFrom, i as writeSite, m as ENGINE_DIR, p as ENGINE_ANCHOR, r as withBase, s as resolveContext, t as assertSafeOutDir, u as resolveTheme } from "./site-X7q76qYf.js";
+import { createRequire } from "node:module";
+import { copyFile, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, extname, join, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { build, createServer, isRunnableDevEnvironment, searchForWorkspaceRoot } from "vite";
+import { createHash } from "node:crypto";
+import { createReadStream, existsSync, readFileSync, readdirSync } from "node:fs";
+import { loadConfig } from "@yaakdoc/config/node";
+import { escapeRegExp } from "@yaakdoc/core";
+import { detectExport } from "@yaakdoc/core/node";
+import { tmpdir } from "node:os";
+import { createServer as createServer$1 } from "node:http";
+import { consola } from "consola";
+import colors from "picocolors";
+import { glob } from "tinyglobby";
+import sirv from "sirv";
+//#region src/node/plugin.ts
+const VIRTUAL_SERVER = "virtual:yaakdoc/entry-server";
+/** The SSR entry exports `render` (see `RenderEntry`). */
+const VIRTUAL_CLIENT = "virtual:yaakdoc/entry-client";
+const RESOLVED = (id) => `\0${id}`;
+const isBare = (id) => !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("\0") && !/^[a-z]+:/i.test(id) && !id.startsWith("@/");
+const json = (value) => JSON.stringify(value);
+const REACT_RE = /^react(-dom)?(\/|$)/;
+const CJS_PREFIX = "\0yaakdoc-cjs:";
+const IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/;
+/** ESM module re-exporting a CommonJS module required from yaakdoc's installation. */
+function cjsWrapper(specifier) {
+	const mod = createRequire(ENGINE_ANCHOR)(specifier);
+	const names = Object.keys(mod).filter((name) => name !== "default" && IDENTIFIER_RE.test(name));
+	return [
+		`import { createRequire } from "node:module";`,
+		`const mod = createRequire(${json(ENGINE_ANCHOR)})(${json(specifier)});`,
+		"export default mod;",
+		names.length > 0 ? `export const { ${names.join(", ")} } = mod;` : ""
+	].join("\n");
+}
+/**
+* The yaakdoc Vite plugin: virtual SSR/client entries, theme-scoped `@/` alias, and fallback
+* resolution of theme dependencies from the yaakdoc installation (so ejected themes and `npx` work
+* without installing anything in the project).
+*/
+function yaakdocPlugin(getContext, onSsrUpdate) {
+	return {
+		name: "yaakdoc",
+		enforce: "pre",
+		async resolveId(source, importer, options) {
+			if (source === "virtual:yaakdoc/entry-server" || source === "virtual:yaakdoc/entry-client") return RESOLVED(source);
+			const { theme } = getContext();
+			if (source.startsWith("@/") && importer?.startsWith(theme.root + sep)) return this.resolve(join(theme.root, "src", source.slice(2)), importer, {
+				...options,
+				skipSelf: true
+			});
+			if (!isBare(source)) return null;
+			const server = this.environment.config.consumer === "server";
+			const finish = (resolved) => {
+				if (!resolved) return null;
+				if (server) return REACT_RE.test(source) ? {
+					...resolved,
+					external: true
+				} : resolved;
+				return optimized(this.environment, resolved, options.scan);
+			};
+			if (REACT_RE.test(source) && server && this.environment.mode === "dev") return `${CJS_PREFIX}${source}`;
+			if (REACT_RE.test(source)) return finish(await this.resolve(source, ENGINE_ANCHOR, {
+				...options,
+				skipSelf: true
+			}));
+			if (!(!importer || importer.startsWith("\0"))) {
+				const resolved = await this.resolve(source, importer, {
+					...options,
+					skipSelf: true
+				});
+				if (resolved) return finish(resolved);
+			}
+			for (const fallback of [
+				ENGINE_ANCHOR,
+				...theme.fallbackImporters,
+				join(theme.root, "package.json")
+			]) {
+				const resolved = await this.resolve(source, fallback, {
+					...options,
+					skipSelf: true
+				});
+				if (resolved) return finish(resolved);
+			}
+			return null;
+		},
+		load(id) {
+			if (id.startsWith(CJS_PREFIX)) return cjsWrapper(id.slice(13));
+			const context = getContext();
+			if (id === RESOLVED("virtual:yaakdoc/entry-server")) return [
+				`import theme from ${json(context.theme.entry)};`,
+				`import { renderPage } from "@yaakdoc/react/server";`,
+				"export function render(input) {",
+				"  return renderPage({ theme, ...input });",
+				"}"
+			].join("\n");
+			if (id === RESOLVED("virtual:yaakdoc/entry-client")) return [
+				...styleEntries(context).map((style) => `import ${json(style)};`),
+				`import { hydrateIslands } from "@yaakdoc/react/client";`,
+				context.theme.client ? `import islands from ${json(context.theme.client)};` : `import { builtinIslands as islands } from "@yaakdoc/react/islands";`,
+				"hydrateIslands(islands);"
+			].join("\n");
+			return null;
+		},
+		hotUpdate({ modules, file }) {
+			if (this.environment.name !== "ssr" || modules.length === 0 || /\.css($|\?)/.test(file)) return;
+			onSsrUpdate?.();
+		}
+	};
+}
+const NODE_MODULES_RE = /[\\/]node_modules[\\/]/;
+const JS_RE = /\.(m?js|cjs)$/;
+/**
+* Dev only: maps a dependency in node_modules to its pre-bundled version.
+*
+* Vite skips dependency discovery for imports coming from inside node_modules – which is where
+* yaakdoc and its theme live when run with `npx`. Such dependencies are registered here by absolute
+* path (reusing an existing entry for the same file), so they are served pre-bundled as ESM.
+*/
+function optimized(environment, resolved, scan) {
+	const optimizer = environment.mode === "dev" ? environment.depsOptimizer : void 0;
+	if (!optimizer || scan || resolved.external) return resolved;
+	const file = resolved.id.split("?")[0];
+	if (!NODE_MODULES_RE.test(file) || !JS_RE.test(file) || optimizer.isOptimizedDepFile(file)) return resolved;
+	const { optimized: done, discovered } = optimizer.metadata;
+	const info = done[file] ?? discovered[file] ?? [...Object.values(done), ...Object.values(discovered)].find((dep) => dep.src === file) ?? optimizer.registerMissingImport(file, file);
+	return optimizer.getOptimizedDepId(info);
+}
+/** CSS entries loaded on every page: the theme's styles, then `branding.customCss`. */
+function styleEntries(context) {
+	const { customCss } = context.config.branding;
+	return [...context.theme.styles, ...customCss ? [customCss] : []];
+}
+const nodeModulesRoot = (file) => {
+	const index = file.lastIndexOf(`${sep}node_modules${sep}`);
+	return index === -1 ? dirname(file) : file.slice(0, index + `${sep}node_modules`.length);
+};
+//#endregion
+//#region src/node/vite.ts
+/** Base Vite config shared by the dev server and builds. */
+async function createViteConfig(getContext, mode, extra = {}) {
+	const context = getContext();
+	const themePlugins = await context.theme.definition.vitePlugins?.() ?? [];
+	const publicDir = join(context.root, "public");
+	const cacheDir = existsSync(join(context.root, "node_modules")) ? join(context.root, "node_modules", ".vite-yaakdoc") : join(tmpdir(), "yaakdoc-vite", createHash("sha256").update(context.root).digest("hex").slice(0, 12));
+	return {
+		configFile: false,
+		envDir: false,
+		root: context.root,
+		base: context.config.base,
+		mode,
+		logLevel: extra.logLevel ?? "warn",
+		clearScreen: false,
+		publicDir: existsSync(publicDir) ? publicDir : false,
+		cacheDir,
+		plugins: [yaakdocPlugin(getContext, extra.onSsrUpdate), ...themePlugins],
+		resolve: { alias: styleAliases(context) },
+		oxc: { jsx: {
+			runtime: "automatic",
+			importSource: "react"
+		} },
+		ssr: { noExternal: [
+			"@yaakdoc/react",
+			/^@yaakdoc\/theme-/,
+			/^yaakdoc-theme-/
+		] },
+		optimizeDeps: { entries: [] },
+		build: { rolldownOptions: { onLog(level, log, handler) {
+			if (log.code === "MODULE_LEVEL_DIRECTIVE") return;
+			handler(level, log);
+		} } },
+		server: { fs: { allow: [
+			searchForWorkspaceRoot(context.root),
+			cacheDir,
+			context.theme.root,
+			nodeModulesRoot(ENGINE_DIR),
+			...context.theme.fallbackImporters.map(nodeModulesRoot)
+		] } }
+	};
+}
+/**
+* CSS `@import "pkg"` is resolved by Vite's CSS resolver (aliases only, no plugins). For CSS packages
+* an ejected theme doesn't have installed (e.g. `tailwindcss`), alias them to yaakdoc's copy.
+*/
+function styleAliases(context) {
+	const themeAnchor = join(context.theme.root, "package.json");
+	const aliases = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const fallback of context.theme.fallbackImporters) {
+		let dependencies = [];
+		try {
+			dependencies = Object.keys(JSON.parse(readFileSync(fallback, "utf8")).dependencies ?? {});
+		} catch {}
+		for (const name of dependencies) {
+			if (seen.has(name)) continue;
+			seen.add(name);
+			if (resolveFrom(`${name}/package.json`, themeAnchor)) continue;
+			const pkgJson = resolveFrom(`${name}/package.json`, fallback);
+			if (!pkgJson) continue;
+			const pkg = JSON.parse(readFileSync(pkgJson, "utf8"));
+			const root = pkg.exports?.["."];
+			const style = typeof root === "object" && root && "style" in root ? root.style : pkg.style;
+			if (typeof style === "string") aliases.push({
+				find: new RegExp(`^${escapeRegExp(name)}$`),
+				replacement: join(dirname(pkgJson), style)
+			});
+		}
+	}
+	return aliases;
+}
+//#endregion
+//#region src/node/build.ts
+const SSR_DIR = ".yaakdoc-ssr";
+/** Builds the static site: client assets, prerendered HTML for every route, Markdown and llms.txt. */
+async function build$1(options = {}) {
+	const previousEnv = process.env.NODE_ENV;
+	process.env.NODE_ENV = "production";
+	try {
+		return await buildWithContext(await resolveContext(options));
+	} finally {
+		if (previousEnv === void 0) delete process.env.NODE_ENV;
+		else process.env.NODE_ENV = previousEnv;
+	}
+}
+async function buildWithContext(context) {
+	const outDir = context.config.outDir;
+	assertSafeOutDir(outDir, context.root);
+	const { assets, ssrEntry } = await bundleTheme(context, outDir);
+	const { render } = await import(pathToFileURL(ssrEntry).href);
+	const files = await writeSite(context, {
+		render,
+		assets: withBase(assets, context.config.base)
+	});
+	await rm(dirname(ssrEntry), {
+		recursive: true,
+		force: true
+	});
+	return {
+		outDir,
+		files,
+		context
+	};
+}
+/**
+* Builds the theme with Vite: the island runtime and CSS into `outDir` (emptied first), and the SSR
+* entry, fully bundled so it runs from anywhere. Pass `base: "./"` for client assets that work
+* under any base path (used to precompile the theme bundled into the Yaak plugin).
+*/
+async function bundleTheme(context, outDir, options = {}) {
+	const getContext = () => context;
+	const base = {
+		...await createViteConfig(getContext, "production"),
+		...options.base ? { base: options.base } : {}
+	};
+	await build({
+		...base,
+		build: {
+			outDir,
+			emptyOutDir: true,
+			manifest: true,
+			assetsDir: "_yaakdoc",
+			copyPublicDir: true,
+			rolldownOptions: {
+				...base.build?.rolldownOptions,
+				input: { client: VIRTUAL_CLIENT }
+			}
+		}
+	});
+	const ssrOutDir = join(outDir, SSR_DIR);
+	await build({
+		...base,
+		publicDir: false,
+		define: { "process.env.NODE_ENV": JSON.stringify("production") },
+		ssr: {
+			...base.ssr,
+			noExternal: true
+		},
+		build: {
+			ssr: true,
+			outDir: ssrOutDir,
+			emptyOutDir: true,
+			copyPublicDir: false,
+			rolldownOptions: {
+				...base.build?.rolldownOptions,
+				input: { "entry-server": VIRTUAL_SERVER },
+				output: {
+					entryFileNames: "[name].mjs",
+					format: "esm"
+				}
+			}
+		}
+	});
+	const manifest = JSON.parse(await readFile(join(outDir, ".vite", "manifest.json"), "utf8"));
+	await rm(join(outDir, ".vite"), {
+		recursive: true,
+		force: true
+	});
+	return {
+		assets: assetsFromManifest(manifest),
+		ssrEntry: join(ssrOutDir, "entry-server.mjs")
+	};
+}
+/** Client assets of the build, relative to the output directory. */
+function assetsFromManifest(manifest) {
+	const entry = Object.values(manifest).find((chunk) => chunk.isEntry);
+	if (!entry) throw new Error("Client build produced no entry chunk.");
+	const collectImports = (keys = [], seen = /* @__PURE__ */ new Set()) => keys.flatMap((key) => {
+		if (seen.has(key)) return [];
+		seen.add(key);
+		const chunk = manifest[key];
+		return chunk ? [chunk.file, ...collectImports(chunk.imports, seen)] : [];
+	});
+	const css = /* @__PURE__ */ new Set([...entry.css ?? []]);
+	for (const key of entry.imports ?? []) for (const file of manifest[key]?.css ?? []) css.add(file);
+	return {
+		styles: [...css],
+		scripts: [entry.file],
+		inlineStyles: [],
+		modulePreloads: collectImports(entry.imports)
+	};
+}
+//#endregion
+//#region src/node/server.ts
+const CONTENT_TYPES = {
+	".md": "text/markdown; charset=utf-8",
+	".txt": "text/plain; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".avif": "image/avif",
+	".ico": "image/x-icon",
+	".css": "text/css; charset=utf-8",
+	".woff2": "font/woff2"
+};
+/** Interface to listen on: a given host, all interfaces (`true`), or localhost. */
+const listenHostname = (host) => typeof host === "string" ? host : host ? "0.0.0.0" : "localhost";
+/** URL to print/open for a server (all-interfaces hosts are shown as localhost). */
+function serverUrl(host, port, base) {
+	const hostname = listenHostname(host);
+	return `http://${hostname === "0.0.0.0" ? "localhost" : hostname}:${port}${base}`;
+}
+/** Listens on `port`, trying the next ports when it is taken. */
+function listen(server, port, host) {
+	const hostname = listenHostname(host);
+	return new Promise((resolvePort, reject) => {
+		let attempt = 0;
+		const tryListen = (candidate) => {
+			server.once("error", (error) => {
+				if (error.code === "EADDRINUSE" && attempt++ < 20 && port !== 0) tryListen(candidate + 1);
+				else reject(error);
+			});
+			server.listen(candidate, hostname, () => resolvePort(server.address().port));
+		};
+		tryListen(port);
+	});
+}
+//#endregion
+//#region src/node/dev.ts
+/** Starts the development server with SSR, HMR for theme code/CSS and reload on export changes. */
+async function createDevServer(options = {}) {
+	let context = await resolveContext(options);
+	const getContext = () => context;
+	const httpServer = createServer$1();
+	let vite;
+	const fullReload = () => vite?.ws.send({
+		type: "full-reload",
+		path: "*"
+	});
+	const config = await createViteConfig(getContext, "development", { onSsrUpdate: fullReload });
+	vite = await createServer({
+		...config,
+		appType: "custom",
+		server: {
+			...config.server,
+			middlewareMode: true,
+			hmr: { server: httpServer }
+		}
+	});
+	const ssr = vite.environments.ssr;
+	if (!ssr || !isRunnableDevEnvironment(ssr)) throw new Error("The Vite SSR environment is not runnable.");
+	const render = async (route, url) => {
+		const { render } = await ssr.runner.import(VIRTUAL_SERVER);
+		const inlineStyles = await Promise.all(styleEntries(context).map(async (file) => {
+			return {
+				id: file,
+				css: (await ssr.runner.import(`${file}?inline`)).default
+			};
+		}));
+		const html = await render({
+			document: context.document,
+			site: context.site,
+			page: route.page,
+			assets: {
+				styles: [],
+				inlineStyles,
+				scripts: [`${context.config.base}@id/__x00__${VIRTUAL_CLIENT}`],
+				modulePreloads: []
+			}
+		});
+		return vite.transformIndexHtml(url, html);
+	};
+	vite.middlewares.use(async (req, res, next) => {
+		const url = req.url ?? "/";
+		const pathname = decodeURIComponent(url.split(/[?#]/)[0] ?? "/");
+		try {
+			const assetFile = context.assets.get(pathname);
+			if (assetFile && existsSync(assetFile)) {
+				res.setHeader("Content-Type", CONTENT_TYPES[extname(assetFile)] ?? "application/octet-stream");
+				createReadStream(assetFile).pipe(res);
+				return;
+			}
+			const route = matchRoute(context, pathname);
+			const text = context.textFiles.get(pathname) ?? (route && wantsMarkdown(req) ? context.textFiles.get(route.page.markdownUrl ?? "") : void 0);
+			if (text !== void 0) {
+				res.setHeader("Content-Type", CONTENT_TYPES[extname(pathname)] ?? CONTENT_TYPES[".md"]);
+				res.end(text);
+				return;
+			}
+			if (req.method !== "GET" && req.method !== "HEAD") return next();
+			if (route || isHtmlRequest(req, pathname)) {
+				const html = await render(route ?? context.notFound, url);
+				res.statusCode = route ? 200 : 404;
+				res.setHeader("Content-Type", "text/html; charset=utf-8");
+				res.end(html);
+				return;
+			}
+			next();
+		} catch (error) {
+			vite.ssrFixStacktrace(error);
+			consola.error(error);
+			res.statusCode = 500;
+			res.setHeader("Content-Type", "text/html; charset=utf-8");
+			res.end(errorPage(error));
+		}
+	});
+	httpServer.on("request", vite.middlewares);
+	if (options.watch !== false) {
+		const watched = new Set(context.watchFiles.map((file) => resolve(file)));
+		vite.watcher.add([...watched]);
+		let timer;
+		const onChange = (file) => {
+			if (!watched.has(resolve(file))) return;
+			clearTimeout(timer);
+			timer = setTimeout(async () => {
+				try {
+					const previous = context;
+					const next = await resolveContext(options);
+					if (next.theme.root !== previous.theme.root || next.config.base !== previous.config.base) consola.warn("The theme or base path changed. Restart yaakdoc to apply it.");
+					context = next;
+					for (const file of next.watchFiles) if (!watched.has(resolve(file))) {
+						watched.add(resolve(file));
+						vite.watcher.add(file);
+					}
+					const mod = ssr.moduleGraph.getModuleById(`\0${VIRTUAL_SERVER}`);
+					if (mod) ssr.moduleGraph.invalidateModule(mod);
+					consola.success(`Reloaded ${colors.dim(file.replace(`${context.root}/`, ""))}`);
+					options.onReload?.(context);
+					fullReload();
+				} catch (error) {
+					consola.error(error.message);
+				}
+			}, 50);
+		};
+		vite.watcher.on("change", onChange);
+		vite.watcher.on("add", onChange);
+	}
+	const port = await listen(httpServer, options.port ?? context.config.server.port, options.host ?? context.config.server.host);
+	const url = serverUrl(options.host ?? context.config.server.host, port, context.config.base);
+	if (options.open ?? context.config.server.open) {
+		const { default: openBrowser } = await import("./open-C4Bh1af9.js");
+		openBrowser(url);
+	}
+	return {
+		url,
+		vite,
+		httpServer,
+		getContext,
+		close: async () => {
+			await vite.close();
+			await new Promise((done) => httpServer.close(() => done()));
+		}
+	};
+}
+function wantsMarkdown(req) {
+	const accept = req.headers.accept ?? "";
+	return accept.includes("text/markdown") && !accept.includes("text/html");
+}
+function isHtmlRequest(req, pathname) {
+	return (req.headers.accept ?? "").includes("text/html") && !extname(pathname);
+}
+const escapeHtml = (value) => value.replace(/[&<>"]/g, (char) => ({
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;"
+})[char]);
+function errorPage(error) {
+	return `<!doctype html><meta charset="utf-8"><title>yaakdoc error</title><style>body{font:14px/1.5 ui-monospace,monospace;padding:2rem;background:#1e1e2e;color:#f5e0dc}pre{white-space:pre-wrap;color:#f38ba8}</style><h1>Render error</h1><pre>${escapeHtml(error.stack ?? error.message)}</pre><script type="module" src="/@vite/client"><\/script>`;
+}
+//#endregion
+//#region src/node/fs.ts
+/** Writes pretty-printed JSON with a trailing newline (like editors and formatters do). */
+function writeJson(file, value) {
+	return writeFile(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+//#endregion
+//#region src/node/init.ts
+/** `$schema` value for yaakdoc.config.json: local copy when installed, otherwise unpkg. */
+function schemaUrl(cwd) {
+	const local = join(cwd, "node_modules", "yaakdoc", "config.schema.json");
+	return existsSync(local) ? "./node_modules/yaakdoc/config.schema.json" : `https://unpkg.com/yaakdoc@${VERSION}/config.schema.json`;
+}
+/** Writes a yaakdoc.config.json (with `$schema` for editor autocomplete). */
+async function init(options = {}) {
+	const cwd = resolve(options.cwd ?? process.cwd());
+	const file = join(cwd, "yaakdoc.config.json");
+	if (existsSync(file) && !options.force) throw new Error("yaakdoc.config.json already exists.");
+	const config = {
+		$schema: schemaUrl(cwd),
+		...options.config
+	};
+	if (!config.export) try {
+		config.export = `./${relative(cwd, await detectExport(cwd))}`;
+	} catch {}
+	await writeJson(file, config);
+	return {
+		file,
+		config
+	};
+}
+//#endregion
+//#region src/node/eject.ts
+const DEFAULT_IGNORE = [
+	"node_modules/**",
+	"dist/**",
+	"package.json",
+	"CHANGELOG.md",
+	"**/*.test.*",
+	"test/**"
+];
+/** Copies the current theme's source into the project so it can be customized freely. */
+async function eject(options = {}) {
+	const cwd = resolve(options.cwd ?? process.cwd());
+	const { config, configFile, root } = await loadConfig({
+		cwd,
+		...options.configFile ? { configFile: options.configFile } : {}
+	});
+	const theme = await resolveTheme(config.theme, {
+		root,
+		themeOptions: config.themeOptions
+	});
+	const out = resolve(cwd, options.out ?? "theme");
+	if (out === theme.root) throw new Error(`The theme is already located at ${out}.`);
+	if (existsSync(out) && readdirSync(out).length > 0 && !options.force) throw new Error(`${relative(cwd, out) || out} already exists and is not empty. Use --force to overwrite.`);
+	const files = await glob(theme.definition.eject?.files ?? ["**/*"], {
+		cwd: theme.root,
+		ignore: DEFAULT_IGNORE,
+		dot: false,
+		onlyFiles: true
+	});
+	if (!files.some((file) => resolve(theme.root, file) === theme.manifest)) files.push(relative(theme.root, theme.manifest));
+	for (const file of files) {
+		const target = join(out, file);
+		await mkdir(dirname(target), { recursive: true });
+		await copyFile(join(theme.root, file), target);
+	}
+	let configResult = null;
+	if (options.updateConfig !== false) {
+		const themePath = `./${relative(configFile ? dirname(configFile) : cwd, out).split("\\").join("/")}`;
+		if (configFile && extname(configFile).startsWith(".json")) {
+			const json = JSON.parse(await readFile(configFile, "utf8"));
+			json.theme = themePath;
+			await writeJson(configFile, json);
+			configResult = {
+				file: configFile,
+				updated: true,
+				created: false
+			};
+		} else if (configFile) configResult = {
+			file: configFile,
+			updated: false,
+			created: false
+		};
+		else {
+			const file = join(cwd, "yaakdoc.config.json");
+			await writeJson(file, {
+				$schema: schemaUrl(cwd),
+				theme: themePath
+			});
+			configResult = {
+				file,
+				updated: true,
+				created: true
+			};
+		}
+	}
+	return {
+		out,
+		files: files.sort(),
+		theme: theme.name,
+		dependencies: theme.definition.eject?.dependencies ?? [],
+		config: configResult
+	};
+}
+//#endregion
+//#region src/node/preview.ts
+/** Serves a built site (like a static host would, including 404.html and base path). */
+async function preview(options = {}) {
+	const { config } = await loadConfig({
+		cwd: options.cwd ?? process.cwd(),
+		...options.configFile ? { configFile: options.configFile } : {}
+	});
+	const outDir = options.outDir ? resolve(options.cwd ?? process.cwd(), options.outDir) : config.outDir;
+	if (!existsSync(join(outDir, "index.html"))) throw new Error(`No build found in ${outDir}. Run \`yaakdoc build\` first.`);
+	const serve = sirv(outDir, {
+		dev: true,
+		etag: true,
+		extensions: ["html"],
+		setHeaders: (res, pathname) => {
+			const type = CONTENT_TYPES[extname(pathname)];
+			if (type) res.setHeader("Content-Type", type);
+		}
+	});
+	const notFoundFile = join(outDir, "404.html");
+	const base = config.base;
+	const server = createServer$1((req, res) => {
+		const url = req.url ?? "/";
+		if (!url.startsWith(base) && base !== "/") {
+			res.writeHead(302, { Location: base });
+			res.end();
+			return;
+		}
+		req.url = base === "/" ? url : url.slice(base.length - 1);
+		serve(req, res, () => {
+			res.statusCode = 404;
+			if (existsSync(notFoundFile)) {
+				res.setHeader("Content-Type", "text/html; charset=utf-8");
+				res.end(readFileSync(notFoundFile));
+			} else res.end("Not found");
+		});
+	});
+	const host = options.host ?? config.server.host;
+	const url = serverUrl(host, await listen(server, options.port ?? config.server.port, host), base);
+	if (options.open) (await import("./open-C4Bh1af9.js")).default(url);
+	return {
+		url,
+		server,
+		close: () => new Promise((done) => server.close(() => done()))
+	};
+}
+//#endregion
+export { createDevServer as a, VIRTUAL_CLIENT as c, schemaUrl as i, VIRTUAL_SERVER as l, eject as n, build$1 as o, init as r, bundleTheme as s, preview as t, yaakdocPlugin as u };