@torpor/build 1.0.0 → 1.0.1

package/src/run/devPlugin.ts

@@ -1,128 +0,0 @@
-import { type IncomingMessage, type ServerResponse } from "node:http";
-import { existsSync, promises as fs } from "node:fs";
-import path from "node:path";
-import { Readable } from "node:stream";
-import { type Plugin, type ViteDevServer } from "vite";
-import { serverError } from "../response.ts";
-import Server from "../server/Server.ts";
-import flattenHeaders from "../server/connect/flattenHeaders.ts";
-import type Site from "../site/Site.ts";
-import prepareTemplate from "./prepareTemplate.ts";
-
-type ReqHandler = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-
-/**
- * The default Node-runtime dev plugin. Reads `src/site.html`, sets up a torpor
- * `Server` whose catch-all route renders via `vite.ssrLoadModule`, and registers
- * a Connect middleware (after Vite's own middlewares) that bridges Node
- * req/res to the torpor Server's fetch handler.
- *
- * Adapters that need a different runtime (e.g. workerd) provide their own
- * `dev()` plugin instead.
- */
-export default function devPlugin(site: Site): Plugin {
-	return {
-		name: "torpor-dev",
-		configureServer(vite) {
-			// Kick off async setup immediately; the middleware awaits it so we
-			// don't depend on whether Vite awaits configureServer itself.
-			const handlerPromise = createDevHandler(vite, site);
-			// Return a post-hook so our middleware runs AFTER Vite's internal
-			// middlewares (static serving, transforms, HMR), acting as the SSR
-			// fallback.
-			return () => {
-				vite.middlewares.use(async (req, res, next) => {
-					try {
-						const handler = await handlerPromise;
-						await handler(req, res);
-					} catch (e) {
-						next(e as Error);
-					}
-				});
-			};
-		},
-	};
-}
-
-async function createDevHandler(vite: ViteDevServer, site: Site): Promise<ReqHandler> {
-	const siteFolder = path.resolve(site.root, "./node_modules/@torpor/build/src/site/");
-	const serverScript = path.join(siteFolder, "serverEntry.ts");
-
-	// Read site.html if present
-	// It's called site.html because @torpor/build builds the site (html, routes
-	// etc) while the user builds the app (components etc). An endpoints-only
-	// site has no site.html, and no template is needed
-	let template: string | undefined;
-	const templateFile = path.resolve(site.root, "src/site.html");
-	if (existsSync(templateFile)) {
-		template = await fs.readFile(templateFile, "utf-8");
-
-		// Apply Vite HTML transforms. This injects the Vite HMR client, and also
-		// applies HTML transforms from Vite plugins. Note that we only support a
-		// universal transform, not individual transforms for each route
-		template = await vite.transformIndexHtml("", template);
-
-		// Prepare site.html so that we can just splice components into it
-		const clientScript = path.join(siteFolder, "clientEntry.ts");
-		const clientDevScript = path.join(siteFolder, "clientEntryDev.ts");
-		template = prepareTemplate(template, clientScript, clientDevScript);
-	}
-
-	const server = new Server();
-
-	// Every request (GET, POST, etc) goes through loadEndPoint
-	server.add("*", async (ev) => {
-		try {
-			// Load the server entry. ssrLoadModule automatically transforms ESM
-			// source code to be usable in Node.js. No bundling is required, and
-			// it provides efficient invalidation similar to HMR
-			const { load } = await vite.ssrLoadModule(serverScript);
-
-			// Render the app HTML (or fetch server data etc) via serverEntry's
-			// exported `load` function
-			return await load(ev, template);
-		} catch (e: any) {
-			// If an error is caught, let Vite fix the stack trace so it maps
-			// back to your actual source code
-			vite.ssrFixStacktrace(e);
-			return serverError(e);
-		}
-	});
-
-	// Put adapter-specific functionality in the `adapter` property of
-	// globalThis for now
-	// @ts-ignore
-	globalThis.adapter = { env: process.env };
-
-	return async (req, res) => {
-		const request = await nodeReqToRequest(req);
-		const response = await server.fetch(request);
-		await sendResponse(response, res);
-	};
-}
-
-async function nodeReqToRequest(req: IncomingMessage): Promise<Request> {
-	const url = req.url ?? "/";
-	const host = req.headers.host ?? "localhost";
-	const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https" : "http";
-	const init: RequestInit = {
-		method: req.method,
-		headers: flattenHeaders(req.headers),
-	};
-	if (req.method !== "GET" && req.method !== "HEAD") {
-		init.body = Readable.toWeb(req) as ReadableStream;
-		// @ts-ignore duplex is required when streaming a body
-		init.duplex = "half";
-	}
-	return new Request(`${protocol}://${host}${url}`, init);
-}
-
-async function sendResponse(response: Response, res: ServerResponse): Promise<void> {
-	res.statusCode = response.status;
-	response.headers.forEach((value, key) => res.setHeader(key, value));
-	if (!response.body) {
-		res.end();
-		return;
-	}
-	Readable.fromWeb(response.body as unknown as import("node:stream/web").ReadableStream).pipe(res);
-}

package/src/run/prepareTemplate.ts

@@ -1,42 +0,0 @@
-export default function prepareTemplate(
-	template: string,
-	clientScript: string,
-	clientDevScript?: string,
-): string {
-	let result = template;
-
-	// Put %COMPONENT_HEAD% before </head>
-	// This is where styles will go
-	let headStart = result.indexOf("</head>");
-	if (headStart === -1) {
-		throw new Error(`Couldn't find <head> end tag`);
-	}
-	result = result.substring(0, headStart) + "%COMPONENT_HEAD%" + result.substring(headStart);
-
-	// Put %COMPONENT_BODY% inside <div id="app"></div>
-	// This is where the component's HTML will go
-	let divMatchStart = regexIndexOf(result, /<div\s+id=("app"|'app'|app)[\s>]/);
-	if (divMatchStart === -1) {
-		throw new Error(`Couldn't find <div id="app"></div>`);
-	}
-	let bodyStart = result.indexOf(">", divMatchStart) + 1;
-	let bodyEnd = result.indexOf("</div>", bodyStart);
-	if (bodyEnd === -1) {
-		throw new Error(`Couldn't find <div id="app"></div>`);
-	}
-	result = result.substring(0, bodyStart) + "%COMPONENT_BODY%" + result.substring(bodyEnd);
-
-	// Add the clientEntry script at the very end, for hydrating and navigating
-	if (clientDevScript) {
-		result += `<script type="module" src="${clientDevScript}"></script>`;
-	}
-	result += `<script type="module" src="${clientScript}"></script>`;
-
-	return result;
-}
-
-// From https://stackoverflow.com/a/274094
-function regexIndexOf(string: string, regex: RegExp, position?: number) {
-	var indexOf = string.substring(position || 0).search(regex);
-	return indexOf >= 0 ? indexOf + (position || 0) : indexOf;
-}

package/src/run/run.ts

@@ -1,86 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { createServer as createViteServer, type ViteDevServer } from "vite";
-import Site from "../site/Site";
-import runBuild from "./runBuild";
-import runDev from "./runDev";
-import runPreview from "./runPreview";
-
-/**
- * Looks for and loads a site.config.js/ts file in the working directory,
- * running the site's plugins. The Vite server used to load the config is
- * returned as well, so that (for example) route files can be loaded through
- * it; callers are responsible for closing it.
- */
-export async function loadSite(folder: string): Promise<{ site: Site; vite: ViteDevServer }> {
-	// Look for and load a site.config.js/ts file in the working directory
-	const jsConfigFile = path.join(folder, "site.config.js");
-	const tsConfigFile = path.join(folder, "site.config.ts");
-	let configFile = "";
-	if (fs.existsSync(jsConfigFile)) {
-		configFile = jsConfigFile;
-	} else if (fs.existsSync(tsConfigFile)) {
-		configFile = tsConfigFile;
-	} else {
-		throw new Error("site.config file not found");
-	}
-
-	// Use a temporary Vite server to load the config, so that local TS imports
-	// (e.g. a routes.ts file) and path aliases are resolved correctly
-	const vite = await createViteServer({
-		server: { middlewareMode: true },
-		appType: "custom",
-		resolve: { tsconfigPaths: true },
-		optimizeDeps: { noDiscovery: true },
-	});
-	try {
-		const site = (await vite.ssrLoadModule(configFile)).default as Site;
-		site.configFile = configFile;
-
-		if (!site || !site.root || !site.routes) {
-			throw new Error("Invalid site in config file");
-		}
-
-		// Run the site's plugins. The manifest plugin also runs them when the
-		// server starts up (dev SSR and production), so that plugin routes are
-		// registered in the runtime as well
-		for (const plugin of site.plugins) {
-			await plugin(site);
-		}
-
-		return { site, vite };
-	} catch (error) {
-		await vite.close();
-		throw error;
-	}
-}
-
-export default async function run(
-	folder: string,
-	mode: "dev" | "build" | "preview",
-): Promise<void> {
-	const { site, vite } = await loadSite(folder);
-	try {
-		switch (mode) {
-			case "dev": {
-				await runDev(site);
-				break;
-			}
-			case "build": {
-				await runBuild(site);
-				break;
-			}
-			case "preview": {
-				await runPreview(site);
-				break;
-			}
-			default: {
-				console.log("No mode passed, running in dev");
-				await runDev(site);
-				break;
-			}
-		}
-	} finally {
-		await vite.close();
-	}
-}

package/src/run/runBuild.ts

@@ -1,128 +0,0 @@
-import torpor from "@torpor/unplugin/vite";
-import { existsSync, promises as fs } from "node:fs";
-import path from "node:path";
-import { build, defineConfig, type AliasOptions } from "vite";
-import Site from "../site/Site";
-import { checkApiCalls, checkRoutes, reportRouteIssues } from "../site/checkRoutes";
-import { checkLayoutSlots } from "../site/checkLayoutSlots";
-import manifest from "../site/manifest.ts";
-import tsconfigAliases, { type AliasEntry } from "../utils/tsconfigAliases";
-import { addTorporPackageConfig } from "../utils/torporPackages";
-
-// TODO: Don't cache index.html in dev?
-// TODO: Don't reload layouts during client routing
-// TODO: Call the correct +page and +server routes when in the same folder
-
-export default async function runBuild(site: Site): Promise<void> {
-	// Check route type annotations and makeApi calls against the routes
-	// derived from file locations, and check that layouts render their slot;
-	// errors fail the build before anything is written
-	let errorCount = reportRouteIssues(checkRoutes(site));
-	errorCount += reportRouteIssues(checkApiCalls(site));
-	errorCount += reportRouteIssues(checkLayoutSlots(site));
-	if (errorCount > 0) {
-		throw new Error(
-			`Route type check failed with ${errorCount} error${errorCount === 1 ? "" : "s"} (see above)`,
-		);
-	}
-
-	// Delete the dist folder if it exists
-	const distFolder = path.resolve(site.root, "dist");
-	if (existsSync(distFolder)) {
-		await fs.rm(distFolder, { recursive: true });
-	}
-	const clientFolder = path.join(distFolder, "client");
-	const serverFolder = path.join(distFolder, "server");
-
-	// HOOK: Prebuild
-	if (site.adapter.prebuild) {
-		await site.adapter.prebuild(site);
-	}
-
-	// TODO: From a setting
-	// An endpoints-only site has no site.html, so everything template-related
-	// is optional
-	const siteHtml = path.resolve(site.root, "src/site.html");
-	const hasSiteHtml = existsSync(siteHtml);
-
-	const siteFolder = path.resolve(site.root, "./node_modules/@torpor/build/src/site/");
-	let clientScript = path.join(siteFolder, "clientEntry.ts");
-	let serverScript = path.join(siteFolder, "serverEntry.ts");
-
-	// Build the client assets, including site.html and the route files
-	// EXCLUDING anything with `server.js` in the name
-	const clientConfig = structuredClone(site.viteConfig ?? {});
-	// Resolve tsconfig path aliases (e.g. `@/*`). Previously provided by the
-	// default `vite-tsconfig-paths` plugin on Site; vite-plus handles it inline
-	// for the client, but hardcodes tsconfigPaths:false on the SSR
-	// externalization path, so mirror tsconfig `compilerOptions.paths` as Vite
-	// `resolve.alias` to resolve them during transform for both client and SSR
-	clientConfig.resolve ??= {};
-	clientConfig.resolve.tsconfigPaths ??= true;
-	clientConfig.resolve.alias = [
-		...asAliasArray(clientConfig.resolve.alias),
-		...tsconfigAliases(site.root),
-	];
-	clientConfig.plugins = [manifest(site), torpor(), ...site.vitePlugins];
-	clientConfig.build ??= {};
-	clientConfig.build.outDir = clientFolder;
-	clientConfig.build.rollupOptions ??= {};
-	clientConfig.build.rollupOptions.input = [
-		...(hasSiteHtml ? [siteHtml] : []),
-		clientScript,
-		...site.routes
-			.filter((r) => r.file && !/server\.(ts|js)$/.test(r.file))
-			.map((r) => path.resolve(site.root, r.file!)),
-		...site.inputs.filter((f) => !/server\.(ts|js)$/.test(f)),
-	];
-	clientConfig.build.ssrManifest = true;
-	await build(defineConfig(clientConfig));
-
-	// Build the server assets, including the server entry script and the route
-	// files
-	const serverConfig = structuredClone(site.viteConfig ?? {});
-	// Resolve tsconfig path aliases (e.g. `@/*`), as above
-	serverConfig.resolve ??= {};
-	serverConfig.resolve.tsconfigPaths ??= true;
-	serverConfig.resolve.alias = [
-		...asAliasArray(serverConfig.resolve.alias),
-		...tsconfigAliases(site.root),
-	];
-	serverConfig.plugins = [manifest(site, true), torpor(), ...site.vitePlugins];
-	serverConfig.build ??= {};
-	serverConfig.build.outDir = serverFolder;
-	// Bundle packages that ship `.torp` files into the server build, as they
-	// need the torpor compiler (Node/workerd can't load them externalized)
-	addTorporPackageConfig(site.root, serverConfig);
-	serverConfig.build.rollupOptions ??= {};
-	serverConfig.build.rollupOptions.input = [
-		serverScript,
-		...site.routes.filter((r) => r.file).map((r) => path.resolve(site.root, r.file!)),
-		...site.inputs,
-	];
-	serverConfig.build.ssr = serverScript;
-	await build(defineConfig(serverConfig));
-
-	// Move the site.html file into /client
-	// HACK: Should do this in Rollup if possible?
-	if (hasSiteHtml) {
-		await fs.rename(
-			path.join(clientFolder, "src", "site.html"),
-			path.join(clientFolder, "site.html"),
-		);
-		await fs.rm(path.join(clientFolder, "src"), { recursive: true });
-	}
-
-	// HOOK: Postbuild
-	if (site.adapter.postbuild) {
-		await site.adapter.postbuild(site);
-	}
-}
-
-function asAliasArray(alias: AliasOptions | undefined): AliasEntry[] {
-	// Normalize an existing `resolve.alias` value (array | object | undefined)
-	// into an array so we can concatenate our tsconfig-derived aliases.
-	if (!alias) return [];
-	if (Array.isArray(alias)) return alias;
-	return Object.entries(alias).map(([find, replacement]) => ({ find, replacement }));
-}

package/src/run/runDev.ts

@@ -1,177 +0,0 @@
-import estorpor from "@torpor/unplugin/esbuild";
-import torpor from "@torpor/unplugin/vite";
-import { configDotenv } from "dotenv";
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import {
-	type AliasOptions,
-	createServer as createViteServer,
-	type Plugin,
-	type ViteDevServer,
-} from "vite";
-import Site from "../site/Site.ts";
-import {
-	checkApiCallSource,
-	checkApiCalls,
-	checkRoute,
-	checkRoutes,
-	createApiCallCheck,
-	type RouteCheckIssue,
-	reportRouteIssues,
-} from "../site/checkRoutes";
-import manifest from "../site/manifest.ts";
-import { checkLayoutSlot, checkLayoutSlots } from "../site/checkLayoutSlots";
-import { LAYOUT_ROUTE } from "../types/RouteType";
-import tsconfigAliases, { type AliasEntry } from "../utils/tsconfigAliases";
-import { addTorporPackageConfig } from "../utils/torporPackages";
-import devPlugin from "./devPlugin.ts";
-import { clearStaleDepCache } from "./depCache";
-import { reportStaleTorpCopies } from "./staleTorpCopies";
-
-export default async function runDev(site: Site): Promise<void> {
-	// Create the Vite dev server. Unlike the previous middleware-mode setup, we
-	// let Vite own the HTTP server (so HMR/websockets work natively) and let the
-	// adapter's `dev()` plugin(s) handle SSR via configureServer.
-	const config = structuredClone(site.viteConfig ?? {});
-	config.appType = "custom";
-	config.server ??= {};
-	config.server.host ??= "localhost";
-	config.server.port ??= 7059;
-	// Resolve tsconfig path aliases (e.g. `@/*`). Previously provided by the
-	// default `vite-tsconfig-paths` plugin on Site; vite-plus handles it inline
-	config.resolve ??= {};
-	config.resolve.tsconfigPaths ??= true;
-	// Resolve `@torpor/view` (runtime, compiler, SSR) from source in dev mode
-	// so changes to the compiler take effect without rebuilding dist.
-	config.resolve.conditions ??= [];
-	config.resolve.conditions.push("development");
-	// vite-plus' `tsconfigPaths` isn't honored by the SSR module-runner's
-	// externalization path (it hardcodes tsconfigPaths:false), so dev SSR can't
-	// resolve path aliases. Mirror tsconfig `compilerOptions.paths` as Vite
-	// `resolve.alias` so they resolve during transform for both client and SSR.
-	config.resolve.alias = [...asAliasArray(config.resolve.alias), ...tsconfigAliases(site.root)];
-
-	// The adapter provides the dev-runtime plugin(s); fall back to the
-	// framework's Node-runtime plugin when it doesn't.
-	const adapterDev = site.adapter.dev?.(site);
-	const devPlugins = normalizePlugins(adapterDev ?? devPlugin(site));
-
-	config.plugins = [
-		manifest(site, true),
-		torpor({ dev: true }),
-		...devPlugins,
-		...site.vitePlugins,
-	];
-
-	// HACK: To be able to import `.torp` files from barrel files in
-	// node_modules, we need to add their libraries to `ssr.noExternal` in
-	// site.config.ts, and let esbuild know how to compile them here
-	config.optimizeDeps ??= {};
-	config.optimizeDeps.extensions ??= [];
-	config.optimizeDeps.extensions.push(".torp");
-	config.optimizeDeps.rolldownOptions ??= {};
-	config.optimizeDeps.rolldownOptions.plugins ??= [estorpor()];
-	// TODO: config.optimizeDeps.rolldownOptions.plugins.push(estorpor());
-
-	// Packages that ship `.torp` files (e.g. icon libraries) need the torpor
-	// compiler: dep optimization would parse them as plain JavaScript and
-	// fail, and SSR externalization would leave raw `.torp` imports that
-	// Node/workerd can't load. Exclude them from optimization and mark them
-	// for SSR bundling so they go through the torpor plugin
-	addTorporPackageConfig(site.root, config);
-
-	// Workspace packages may have been rebuilt since the last dev run; drop
-	// Vite's dep cache so SSR never executes stale prebundled modules
-	clearStaleDepCache(site.root, (message) => console.log(`\n${message}`));
-
-	// A workspace package with dist .torp copies (e.g. @torpor/ui) whose src
-	// changed without a rebuild serves OLD components to the site, silently;
-	// report the drift so it can be fixed with a rebuild
-	reportStaleTorpCopies(site.root, (message) => console.log(`\n${message}`));
-
-	// Load environment variables from a `.env` file, with defaults if not set
-	configDotenv();
-
-	process.env.PROTOCOL ??= "http:";
-	process.env.HOST ??= "localhost";
-	process.env.PORT ??= "7059";
-
-	const connectingUrl = `${process.env.PROTOCOL}//${process.env.HOST}:${process.env.PORT}`;
-	console.log(`\nConnecting to ${connectingUrl}`);
-
-	const vite = await createViteServer(config);
-	await vite.listen();
-
-	watchRouteTypes(site, vite);
-
-	const listeningUrl = vite.resolvedUrls?.local?.[0] ?? connectingUrl;
-	console.log(`Listening on ${listeningUrl}\n`);
-}
-
-/**
- * Reports route type issues at startup, then re-checks route files and
- * `makeApi` calls as they change so annotation problems surface during
- * development without failing the dev server.
- */
-function watchRouteTypes(site: Site, vite: ViteDevServer): void {
-	reportRouteIssues(checkRoutes(site));
-	reportRouteIssues(checkApiCalls(site));
-	reportRouteIssues(checkLayoutSlots(site));
-
-	// Map absolute route file paths to their manifest entries, so changed
-	// files can be re-checked against their derived route. Layout route files
-	// are included for their slot check (a .torp layout is its own component)
-	const routeFiles = new Map(
-		site.routes
-			.filter(
-				(r) => r.file?.endsWith(".ts") || (r.file?.endsWith(".torp") && r.type === LAYOUT_ROUTE),
-			)
-			.map((r) => [path.resolve(site.root, r.file!), r]),
-	);
-	const apiCheck = createApiCallCheck(site);
-	// Only report when a file's issues change, to avoid repeating the same
-	// warnings on every save
-	const reported = new Map<string, string>();
-
-	const report = (file: string, issues: RouteCheckIssue[]) => {
-		const key = JSON.stringify(issues);
-		if (reported.get(file) === key) return;
-		reported.set(file, key);
-		reportRouteIssues(issues);
-	};
-
-	const recheck = (file: string): void => {
-		const route = routeFiles.get(file);
-		if (route) {
-			report(
-				file,
-				route.type === LAYOUT_ROUTE ? checkLayoutSlot(site, route) : checkRoute(site, route),
-			);
-			return;
-		}
-		if (!/\.(ts|js|torp)$/.test(file)) return;
-		let source: string;
-		try {
-			source = readFileSync(file, "utf8");
-		} catch {
-			return;
-		}
-		report(file, checkApiCallSource(source, file, apiCheck));
-	};
-
-	vite.watcher.on("change", recheck);
-	vite.watcher.on("add", recheck);
-}
-
-function normalizePlugins(plugins: Plugin | Plugin[] | void): Plugin[] {
-	if (!plugins) return [];
-	return Array.isArray(plugins) ? plugins : [plugins];
-}
-
-function asAliasArray(alias: AliasOptions | undefined): AliasEntry[] {
-	// Normalize an existing `resolve.alias` value (array | object | undefined)
-	// into an array so we can concatenate our tsconfig-derived aliases.
-	if (!alias) return [];
-	if (Array.isArray(alias)) return alias;
-	return Object.entries(alias).map(([find, replacement]) => ({ find, replacement }));
-}

package/src/run/runOpenApi.ts

@@ -1,52 +0,0 @@
-import { writeFile } from "node:fs/promises";
-import path from "node:path";
-import type { ViteDevServer } from "vite";
-import buildOpenApiDocument from "../openapi/document";
-import { OPEN_API_STATE_KEY } from "../openapi/plugin";
-import type { OpenApiEndPoint, OpenApiRouteEntry, ResolvedOpenApiOptions } from "../openapi/types";
-import type Site from "../site/Site";
-import { SERVER_ROUTE } from "../types/RouteType";
-
-/**
- * Writes an OpenAPI document for the site's +server endpoints to a file.
- * Route files are loaded through the supplied Vite server, so this must be
- * called while the server from `loadSite` is still open.
- */
-export default async function runOpenApi(
-	site: Site,
-	vite: ViteDevServer,
-	outFile = "openapi.json",
-): Promise<void> {
-	const options = site.pluginState.get(OPEN_API_STATE_KEY) as ResolvedOpenApiOptions | undefined;
-	if (!options) {
-		throw new Error(
-			'No OpenAPI options found. Add the openApi() plugin to site.plugins to use "tb --openapi"',
-		);
-	}
-
-	const entries: OpenApiRouteEntry[] = [];
-	for (const route of site.routes) {
-		if (route.type !== SERVER_ROUTE) {
-			continue;
-		}
-		// Don't document the docs page itself
-		if (options.docs && route.path === options.docs) {
-			continue;
-		}
-		if (route.endPoint && !route.file) {
-			// Inline endpoint
-			entries.push({ path: route.path, endPoint: route.endPoint as OpenApiEndPoint });
-		} else if (route.file) {
-			const file = path.resolve(site.root, route.file);
-			const mod = await vite.ssrLoadModule(file);
-			entries.push({ path: route.path, endPoint: mod.default });
-		}
-	}
-
-	const doc = buildOpenApiDocument(entries, options);
-	await writeFile(path.resolve(site.root, outFile), JSON.stringify(doc, null, 2) + "\n");
-
-	console.log(
-		`OpenAPI document written to ${outFile} (${Object.keys(doc.paths ?? {}).length} paths)`,
-	);
-}