yaakdoc 0.1.0 → 0.2.0

package/dist/{preview-2YFamRKo.js → preview-Ba1BfVZV.js}

@@ -1,537 +1,23 @@
+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 { builtinSnippets, generateExamples } from "@yaakdoc/snippets";
 import { copyFile, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { absoluteUrl, escapeRegExp, findWorkspace, isUrl, normalize, prepareDocument, sanitizeExport, selectEnvironment, summarize } from "@yaakdoc/core";
+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, statSync } from "node:fs";
+import { createReadStream, existsSync, readFileSync, readdirSync } from "node:fs";
 import { loadConfig } from "@yaakdoc/config/node";
-import { detectExport, readExport } from "@yaakdoc/core/node";
-import { folderToMarkdown, indexToMarkdown, llmsFullTxt, llmsTxt, requestToMarkdown } from "@yaakdoc/markdown";
-import rehypeShikiFromHighlighter from "@shikijs/rehype/core";
-import { createJiti } from "jiti";
-import rehypeSanitize, { defaultSchema } from "rehype-sanitize";
-import rehypeStringify from "rehype-stringify";
-import remarkGfm from "remark-gfm";
-import remarkParse from "remark-parse";
-import remarkRehype from "remark-rehype";
-import { bundledLanguages, createHighlighter } from "shiki";
-import { unified } from "unified";
+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/render.ts
-const PRELOADED_LANGUAGES = [
-	"bash",
-	"javascript",
-	"typescript",
-	"python",
-	"go",
-	"json",
-	"graphql",
-	"xml",
-	"html",
-	"yaml",
-	"http"
-];
-/** Highlights a delimited region as GraphQL (opening captures: prefix tokens, then the delimiter). */
-const embeddedGraphql = (begin, end, prefixScopes) => ({
-	begin,
-	beginCaptures: Object.fromEntries(prefixScopes.map((name, index) => [index + 1, { name }])),
-	end,
-	endCaptures: { 0: { name: prefixScopes.at(-1) } },
-	contentName: "meta.embedded.block.graphql",
-	patterns: [{ include: "source.graphql" }]
-});
-/**
-* Injection grammar highlighting GraphQL inside code examples (like VS Code's GraphQL extension):
-* `/* GraphQL *\/ \`…\`` and `gql\`…\`` in JavaScript, `query = """…"""` in Python and
-* `query := \`…\`` in Go.
-*/
-const GRAPHQL_INJECTION = {
-	name: "yaakdoc-graphql-injection",
-	scopeName: "inline.graphql.yaakdoc",
-	injectTo: [
-		"source.js",
-		"source.ts",
-		"source.python",
-		"source.go"
-	],
-	injectionSelector: "L:source -comment -string",
-	embeddedLangs: ["graphql"],
-	patterns: [
-		embeddedGraphql("(/\\*\\s*GraphQL\\s*\\*/)\\s*(`)", "`", ["comment.block.js", "punctuation.definition.string.template.begin.js"]),
-		embeddedGraphql("\\b(gql|graphql)(`)", "`", ["entity.name.function.tagged-template.js", "punctuation.definition.string.template.begin.js"]),
-		embeddedGraphql("\\b(query)\\s*(=)\\s*(\"\"\")", "\"\"\"", [
-			"variable.other.python",
-			"keyword.operator.assignment.python",
-			"punctuation.definition.string.begin.python"
-		]),
-		embeddedGraphql("\\b(query)\\s*(:=)\\s*(`)", "`", [
-			"variable.other.go",
-			"keyword.operator.assignment.go",
-			"punctuation.definition.string.begin.go"
-		])
-	]
-};
-const highlighters = /* @__PURE__ */ new Map();
-function getHighlighter(themes) {
-	const key = `${themes.light}|${themes.dark}`;
-	let highlighter = highlighters.get(key);
-	if (!highlighter) {
-		highlighter = createHighlighter({
-			themes: [themes.light, themes.dark],
-			langs: [...PRELOADED_LANGUAGES, GRAPHQL_INJECTION]
-		});
-		highlighters.set(key, highlighter);
-	}
-	return highlighter;
-}
-const LANGUAGE_ALIASES = {
-	shell: "bash",
-	sh: "bash",
-	js: "javascript",
-	ts: "typescript",
-	text: "text",
-	plain: "text"
-};
-async function ensureLanguage(highlighter, language) {
-	const lang = LANGUAGE_ALIASES[language] ?? language;
-	if (lang === "text" || highlighter.getLoadedLanguages().includes(lang)) return lang;
-	if (lang in bundledLanguages) {
-		await highlighter.loadLanguage(lang);
-		return lang;
-	}
-	return "text";
-}
-const sanitizeSchema = {
-	...defaultSchema,
-	attributes: {
-		...defaultSchema.attributes,
-		code: [...defaultSchema.attributes?.code ?? [], ["className", /^language-./]]
-	}
-};
-/**
-* Creates the Markdown/code renderer: GFM, sanitized HTML (descriptions come from exports that may
-* be shared by others), and Shiki highlighting with dual light/dark themes via CSS variables.
-*/
-async function createRenderer(themes) {
-	const highlighter = await getHighlighter(themes);
-	const shikiOptions = {
-		themes,
-		defaultColor: false
-	};
-	const processor = unified().use(remarkParse).use(remarkGfm).use(remarkRehype).use(rehypeSanitize, sanitizeSchema).use(rehypeShikiFromHighlighter, highlighter, {
-		...shikiOptions,
-		fallbackLanguage: "text",
-		lazy: true
-	}).use(rehypeStringify);
-	return {
-		markdown: async (source) => String(await processor.process(source)),
-		highlight: async (code, language) => highlighter.codeToHtml(code, {
-			...shikiOptions,
-			lang: await ensureLanguage(highlighter, language)
-		})
-	};
-}
-/** Loads snippet generators by built-in id or module path/package (default export or `snippet`). */
-async function loadSnippets(ids, root) {
-	const jiti = createJiti(`${root}/`, { interopDefault: true });
-	const snippets = [];
-	for (const id of ids) {
-		const builtin = builtinSnippets[id];
-		if (builtin) {
-			snippets.push(builtin);
-			continue;
-		}
-		if (!existsSync(id) && !id.includes("/") && !id.startsWith("@")) throw new Error(`Unknown snippet "${id}". Built-in snippets: ${Object.keys(builtinSnippets).join(", ")}.`);
-		const mod = await jiti.import(id);
-		const loaded = "default" in mod ? mod.default : mod;
-		for (const snippet of Array.isArray(loaded) ? loaded : [loaded]) {
-			if (!snippet || typeof snippet.generate !== "function") throw new Error(`Snippet module "${id}" must export a snippet created with defineSnippet().`);
-			snippets.push(snippet);
-		}
-	}
-	return snippets;
-}
-//#endregion
-//#region src/node/resolve.ts
-/** Directory of the installed `yaakdoc` package. */
-const ENGINE_DIR = (() => {
-	let dir = dirname(fileURLToPath(import.meta.url));
-	while (!existsSync(join(dir, "package.json"))) dir = dirname(dir);
-	return dir;
-})();
-/** A file inside the engine package, used as importer for fallback resolution. */
-const ENGINE_ANCHOR = join(ENGINE_DIR, "package.json");
-/**
-* Resolves an ESM specifier as if imported from `fromFile`. Returns an absolute path or null.
-*/
-function resolveFrom(specifier, fromFile) {
-	try {
-		const resolved = createJiti(fromFile).esmResolve(specifier, { try: true });
-		return resolved ? resolved.startsWith("file:") ? fileURLToPath(resolved) : resolved : null;
-	} catch {
-		return null;
-	}
-}
-/** Resolves a package directory (the folder containing its package.json). */
-function resolvePackageDir(name, fromFile) {
-	const entry = resolveFrom(`${name}/package.json`, fromFile);
-	if (entry) return dirname(entry);
-	const main = resolveFrom(name, fromFile);
-	if (!main) return null;
-	let dir = dirname(main);
-	while (dir !== dirname(dir)) {
-		if (existsSync(join(dir, "package.json")) && dir.endsWith(name.split("/").at(-1))) return dir;
-		dir = dirname(dir);
-	}
-	return null;
-}
-//#endregion
-//#region src/node/theme.ts
-var ThemeError = class extends Error {
-	name = "ThemeError";
-};
-const MANIFEST_NAMES = [
-	"theme.ts",
-	"theme.mts",
-	"theme.js",
-	"theme.mjs",
-	"index.ts",
-	"index.js"
-];
-/** Candidate package names for a theme spec: `kiseki` → `@yaakdoc/theme-kiseki`, `yaakdoc-theme-kiseki`. */
-function themePackageCandidates(spec) {
-	if (spec.startsWith("@") || spec.includes("/") || spec.startsWith("yaakdoc-theme-")) return [spec];
-	return [
-		`@yaakdoc/theme-${spec}`,
-		`yaakdoc-theme-${spec}`,
-		spec
-	];
-}
-const isLocal = (spec) => spec.startsWith(".") || isAbsolute(spec);
-function findManifest(path) {
-	if (existsSync(path) && statSync(path).isFile()) return path;
-	for (const name of MANIFEST_NAMES) {
-		const candidate = join(path, name);
-		if (existsSync(candidate)) return candidate;
-	}
-	throw new ThemeError(`No theme manifest (${MANIFEST_NAMES.join(", ")}) found in ${path}`);
-}
-/** Built-in theme package directories, used to resolve dependencies of ejected themes. */
-function builtinFallbacks() {
-	const kiseki = resolvePackageDir("@yaakdoc/theme-kiseki", ENGINE_ANCHOR);
-	return [ENGINE_ANCHOR, ...kiseki ? [join(kiseki, "package.json")] : []];
-}
-/** Loads and validates a theme from a short name, package name or local path. */
-async function resolveTheme(spec, options) {
-	const userAnchor = join(options.root, "package.json");
-	let manifest = null;
-	let packageName = null;
-	if (isLocal(spec)) manifest = findManifest(resolve(options.root, spec));
-	else {
-		for (const candidate of themePackageCandidates(spec)) {
-			const resolved = resolveFrom(candidate, userAnchor) ?? resolveFrom(candidate, ENGINE_ANCHOR);
-			if (resolved) {
-				manifest = resolved;
-				packageName = candidate;
-				break;
-			}
-		}
-		if (!manifest) throw new ThemeError(`Theme "${spec}" not found. Install it (e.g. npm i -D ${themePackageCandidates(spec)[0]}) or use a local path.`);
-	}
-	const fallbackImporters = builtinFallbacks();
-	const alias = buildAliases(manifest, fallbackImporters);
-	const jiti = createJiti(manifest, {
-		alias,
-		moduleCache: false,
-		interopDefault: true
-	});
-	let definition;
-	try {
-		definition = await jiti.import(manifest, { default: true });
-	} catch (error) {
-		throw new ThemeError(`Failed to load theme ${manifest}: ${error.message}`);
-	}
-	if (!definition || typeof definition !== "object" || !definition.entry) throw new ThemeError(`Theme ${manifest} must default-export defineTheme({ name, entry, ... }).`);
-	const root = dirname(manifest);
-	const abs = (path) => resolve(root, path);
-	let themeOptions = options.themeOptions;
-	if (definition.options) try {
-		themeOptions = definition.options.parse(options.themeOptions);
-	} catch (error) {
-		throw new ThemeError(`Invalid themeOptions for theme "${definition.name}":\n${error.message}`);
-	}
-	return {
-		name: definition.name,
-		definition,
-		root,
-		manifest,
-		entry: abs(definition.entry),
-		client: definition.client ? abs(definition.client) : null,
-		styles: (definition.styles ?? []).map(abs),
-		options: themeOptions,
-		packageName,
-		fallbackImporters,
-		highlight: definition.highlight ?? {
-			light: "github-light",
-			dark: "github-dark"
-		}
-	};
-}
-/**
-* jiti aliases so a theme manifest (e.g. an ejected theme in a project without dependencies) can
-* import `@yaakdoc/react/theme` and the built-in themes' dependencies.
-*/
-function buildAliases(manifest, fallbacks) {
-	const specs = /* @__PURE__ */ new Set(["@yaakdoc/react/theme", "@yaakdoc/react"]);
-	for (const fallback of fallbacks) try {
-		const pkg = JSON.parse(readFileSync(fallback, "utf8"));
-		for (const name of Object.keys(pkg.dependencies ?? {})) specs.add(name);
-	} catch {}
-	const alias = {};
-	for (const spec of specs) {
-		if (resolveFrom(spec, manifest)) continue;
-		for (const fallback of fallbacks) {
-			const resolved = resolveFrom(spec, fallback);
-			if (resolved) {
-				alias[spec] = resolved;
-				break;
-			}
-		}
-	}
-	return alias;
-}
-//#endregion
-//#region src/node/context.ts
-const VERSION = JSON.parse(readFileSync(resolve(ENGINE_DIR, "package.json"), "utf8")).version;
-/** Loads config, export and theme, and prepares everything needed to render the site. */
-async function resolveContext(options = {}) {
-	const cwd = resolve(options.cwd ?? process.cwd());
-	const { config, configFile, root } = await loadConfig({
-		cwd,
-		...options.configFile ? { configFile: options.configFile } : {},
-		...options.overrides ? { overrides: options.overrides } : {}
-	});
-	const exportPath = config.export ?? await detectExport(root);
-	const rawExport = await readExport(exportPath);
-	const source = normalize(rawExport);
-	const workspace = findWorkspace(source, config.workspace);
-	const environments = config.environments === "public" ? workspace.environments.filter((env) => env.public) : (config.environments ?? []).map((name) => selectEnvironment(workspace, name));
-	const environment = config.environment === false ? null : config.environment === void 0 && environments[0] ? environments[0] : selectEnvironment(workspace, config.environment);
-	const theme = await resolveTheme(config.theme, {
-		root,
-		themeOptions: config.themeOptions
-	});
-	const renderer = await createRenderer(theme.highlight);
-	const snippets = await loadSnippets(config.snippets, root);
-	const document = await prepareDocument({
-		workspace,
-		environment,
-		environments,
-		pages: config.pages,
-		base: config.base,
-		variables: config.variables,
-		filter: config.filter,
-		renderMarkdown: renderer.markdown,
-		highlight: renderer.highlight,
-		examples: (request) => generateExamples(request, snippets),
-		meta: {
-			yaakVersion: source.yaakVersion,
-			exportedAt: source.exportedAt
-		}
-	});
-	const assets = /* @__PURE__ */ new Map();
-	const asset = (path) => publicAsset(path, config.base, assets);
-	const site = await createSiteData(config, document, theme, asset, renderer.markdown);
-	const { routes, notFound } = createRoutes(document, site);
-	const markdownOptions = {
-		title: site.title,
-		description: site.description,
-		base: config.base,
-		...site.url ? { siteUrl: site.url } : {}
-	};
-	const textFiles = /* @__PURE__ */ new Map();
-	if (config.llms.enabled) {
-		textFiles.set(`${config.base}index.md`, config.pages === "single" ? llmsFullTxt(document, markdownOptions) : indexToMarkdown(document, markdownOptions));
-		for (const folder of Object.values(document.folders)) textFiles.set(folder.markdownUrl, folderToMarkdown(document, folder, markdownOptions));
-		for (const request of Object.values(document.requests)) textFiles.set(request.markdownUrl, requestToMarkdown(request, markdownOptions));
-		textFiles.set(`${config.base}llms.txt`, llmsTxt(document, {
-			...markdownOptions,
-			...config.llms.full ? { fullTextUrl: `${config.base}llms-full.txt` } : {}
-		}));
-		if (config.llms.full) textFiles.set(`${config.base}llms-full.txt`, llmsFullTxt(document, markdownOptions));
-	}
-	const externalExport = typeof config.runInYaak === "object" && config.runInYaak.url;
-	if (site.runInYaak && !externalExport) {
-		const shared = shareableExport(rawExport, workspace, document, config.variables.hide);
-		textFiles.set(site.runInYaak.dataUrl, JSON.stringify(shared, null, 2));
-	}
-	return {
-		cwd,
-		root,
-		configFile,
-		config,
-		exportPath,
-		source,
-		theme,
-		document,
-		site,
-		routes,
-		notFound,
-		textFiles,
-		assets,
-		watchFiles: [
-			exportPath,
-			...configFile ? [configFile] : [],
-			...assets.values()
-		]
-	};
-}
-/** The export restricted to what the docs show, safe to publish for "Run in Yaak". */
-function shareableExport(raw, workspace, document, hide) {
-	const environmentIds = new Set(document.environments.map((env) => env.id));
-	if (document.environment) environmentIds.add(document.environment.id);
-	if (workspace.baseEnvironment) environmentIds.add(workspace.baseEnvironment.id);
-	for (const folderId of Object.keys(document.folders)) for (const env of workspace.folderEnvironments[folderId] ?? []) environmentIds.add(env.id);
-	return sanitizeExport(raw, {
-		workspaceId: workspace.id,
-		folderIds: new Set(Object.keys(document.folders)),
-		requestIds: new Set(Object.keys(document.requests)),
-		environmentIds,
-		hide
-	});
-}
-/**
-* Maps a local asset (logo, favicon) to a public URL under `<base>_yaakdoc/`. URLs and site-root
-* paths that don't exist on disk (e.g. `/logo.svg` served from `public/`) are kept as is.
-*/
-function publicAsset(path, base, assets) {
-	if (!path) return null;
-	if (isUrl(path) || !existsSync(path)) return path;
-	const hash = createHash("sha256").update(path).digest("hex").slice(0, 8);
-	const url = `${base}_yaakdoc/${basename(path, extname(path))}-${hash}${extname(path)}`;
-	assets.set(url, path);
-	return url;
-}
-async function createSiteData(config, document, theme, asset, markdown) {
-	const { branding } = config;
-	const title = branding.title ?? document.workspace.name;
-	let logo = null;
-	if (typeof branding.logo === "string") logo = {
-		light: asset(branding.logo) ?? void 0,
-		alt: title,
-		href: config.base
-	};
-	else if (branding.logo) logo = {
-		...branding.logo.light ? { light: asset(branding.logo.light) } : {},
-		...branding.logo.dark ? { dark: asset(branding.logo.dark) } : {},
-		alt: branding.logo.alt ?? title,
-		href: branding.logo.href ?? config.base,
-		...branding.logo.width ? { width: branding.logo.width } : {},
-		...branding.logo.height ? { height: branding.logo.height } : {}
-	};
-	return {
-		title,
-		description: branding.description ?? summarize(document.workspace.description, 200),
-		url: branding.url ?? null,
-		base: config.base,
-		pages: config.pages,
-		logo,
-		favicon: asset(branding.favicon),
-		colors: branding.colors ?? {},
-		fonts: branding.fonts ?? {},
-		links: branding.links,
-		footerHtml: branding.footer ? await markdown(branding.footer) : null,
-		defaultColorMode: branding.defaultColorMode,
-		colorModeToggle: branding.colorModeToggle,
-		llms: {
-			...config.llms,
-			txtUrl: config.llms.enabled ? `${config.base}llms.txt` : null,
-			fullTxtUrl: config.llms.enabled && config.llms.full ? `${config.base}llms-full.txt` : null
-		},
-		showVariables: config.variables.show,
-		runInYaak: config.runInYaak ? {
-			name: typeof config.runInYaak === "object" && config.runInYaak.name || title,
-			dataUrl: typeof config.runInYaak === "object" && config.runInYaak.url || `${config.base}yaak.json`
-		} : null,
-		head: config.head,
-		themeOptions: theme.options,
-		generator: `yaakdoc ${VERSION}`
-	};
-}
-function createRoutes(document, site) {
-	const { base } = site;
-	const llms = site.llms.enabled;
-	const routes = [{
-		path: base,
-		file: "index.html",
-		page: {
-			kind: "index",
-			id: null,
-			path: base,
-			title: "",
-			description: site.description,
-			markdownUrl: llms ? `${base}index.md` : null
-		}
-	}];
-	if (site.pages === "per-request") {
-		for (const folder of Object.values(document.folders)) routes.push({
-			path: folder.href,
-			file: `${folder.slug}/index.html`,
-			page: {
-				kind: "folder",
-				id: folder.id,
-				path: folder.href,
-				title: folder.name,
-				description: folder.summary,
-				markdownUrl: llms ? folder.markdownUrl : null
-			}
-		});
-		for (const request of Object.values(document.requests)) routes.push({
-			path: request.href,
-			file: `${request.slug}/index.html`,
-			page: {
-				kind: "request",
-				id: request.id,
-				path: request.href,
-				title: request.name,
-				description: request.summary,
-				markdownUrl: llms ? request.markdownUrl : null
-			}
-		});
-	}
-	return {
-		routes,
-		notFound: {
-			path: `${base}404.html`,
-			file: "404.html",
-			page: {
-				kind: "not-found",
-				id: null,
-				path: `${base}404.html`,
-				title: "Page not found",
-				description: "",
-				markdownUrl: null
-			}
-		}
-	};
-}
-/** Finds the route for a URL path (ignoring query/hash; `/x` matches `/x/`). */
-function matchRoute(context, pathname) {
-	const path = decodeURIComponent(pathname.split(/[?#]/)[0] ?? "/");
-	const normalized = path.endsWith("/") || path.endsWith(".html") ? path : `${path}/`;
-	return context.routes.find((route) => route.path === normalized || `${route.path}index.html` === path) ?? null;
-}
-//#endregion
 //#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("@/");
@@ -742,8 +228,33 @@ async function build$1(options = {}) {
 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");
+	const base = {
+		...await createViteConfig(getContext, "production"),
+		...options.base ? { base: options.base } : {}
+	};
 	await build({
 		...base,
 		build: {
@@ -782,45 +293,18 @@ async function buildWithContext(context) {
 			}
 		}
 	});
-	const assets = assetsFromManifest(JSON.parse(await readFile(join(outDir, ".vite", "manifest.json"), "utf8")), context.config.base);
-	const { render } = await import(pathToFileURL(join(ssrOutDir, "entry-server.mjs")).href);
-	const files = [];
-	const write = async (file, content) => {
-		const target = join(outDir, file);
-		await mkdir(dirname(target), { recursive: true });
-		await writeFile(target, content);
-		files.push(file);
-	};
-	for (const route of [...context.routes, context.notFound]) await write(route.file, await render({
-		document: context.document,
-		site: context.site,
-		page: route.page,
-		assets
-	}));
-	for (const [url, content] of context.textFiles) await write(stripBase(url, context.config.base), content);
-	for (const [url, source] of context.assets) {
-		const file = stripBase(url, context.config.base);
-		await mkdir(dirname(join(outDir, file)), { recursive: true });
-		await copyFile(source, join(outDir, file));
-		files.push(file);
-	}
-	if (context.site.url) await write("sitemap.xml", sitemap(context));
-	await write(".nojekyll", "");
-	await rm(ssrOutDir, {
-		recursive: true,
-		force: true
-	});
+	const manifest = JSON.parse(await readFile(join(outDir, ".vite", "manifest.json"), "utf8"));
 	await rm(join(outDir, ".vite"), {
 		recursive: true,
 		force: true
 	});
 	return {
-		outDir,
-		files,
-		context
+		assets: assetsFromManifest(manifest),
+		ssrEntry: join(ssrOutDir, "entry-server.mjs")
 	};
 }
-function assetsFromManifest(manifest, base) {
+/** 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) => {
@@ -832,21 +316,12 @@ function assetsFromManifest(manifest, base) {
 	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].map((file) => base + file),
-		scripts: [base + entry.file],
+		styles: [...css],
+		scripts: [entry.file],
 		inlineStyles: [],
-		modulePreloads: collectImports(entry.imports).map((file) => base + file)
+		modulePreloads: collectImports(entry.imports)
 	};
 }
-const stripBase = (url, base) => url.startsWith(base) ? url.slice(base.length) : url.replace(/^\//, "");
-function sitemap(context) {
-	return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${context.routes.map((route) => absoluteUrl(context.site.url, context.config.base, route.path)).map((url) => `  <url><loc>${url}</loc></url>`).join("\n")}\n</urlset>\n`;
-}
-/** Refuses to empty the project directory (or a parent of it). */
-function assertSafeOutDir(outDir, root) {
-	const rel = relative(resolve(outDir), resolve(root));
-	if (rel === "" || !rel.startsWith("..") && !rel.startsWith(sep) && !rel.includes(":")) throw new Error(`Refusing to use ${outDir} as outDir: it contains the project directory and would be emptied.`);
-}
 //#endregion
 //#region src/node/server.ts
 const CONTENT_TYPES = {
@@ -1181,4 +656,4 @@ async function preview(options = {}) {
 	};
 }
 //#endregion
-export { createDevServer as a, VIRTUAL_SERVER as c, matchRoute as d, resolveContext as f, themePackageCandidates as h, schemaUrl as i, yaakdocPlugin as l, resolveTheme as m, eject as n, build$1 as o, ThemeError as p, init as r, VIRTUAL_CLIENT as s, preview as t, VERSION as u };
+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 };