@torpor/build 0.4.14 → 1.0.0

package/dist/runOpenApi-BUi1RH1l.mjs

@@ -0,0 +1,1381 @@
+import { i as buildOpenApiDocument, t as OPEN_API_STATE_KEY } from "./plugin-D8Www11B.mjs";
+import { r as serverError } from "./response-Bg4w2S1q.mjs";
+import { n as Server, t as flattenHeaders } from "./flattenHeaders-C_YYLdOq.mjs";
+import { createRequire, isBuiltin } from "node:module";
+import fs, { existsSync, promises, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import fpath from "node:path";
+import { build, createServer, defineConfig } from "vite";
+import torpor from "@torpor/unplugin/vite";
+import { parse } from "@torpor/view/compile";
+import estorpor from "@torpor/unplugin/esbuild";
+import { configDotenv } from "dotenv";
+import { Readable } from "node:stream";
+import { createHash } from "node:crypto";
+import { writeFile } from "node:fs/promises";
+//#region src/utils/tsconfigAliases.ts
+/**
+* Reads `tsconfig.json` `compilerOptions.paths` (relative to `baseUrl`,
+* defaulting to the tsconfig directory) and converts them to Vite
+* `resolve.alias` entries. Only handles paths declared in the root tsconfig
+* (not inherited via `extends`).
+*/
+function tsconfigAliases(root) {
+	const file = fpath.join(root, "tsconfig.json");
+	let paths;
+	let baseUrl;
+	try {
+		const compilerOptions = JSON.parse(stripJsonc(readFileSync(file, "utf-8"))).compilerOptions ?? {};
+		baseUrl = compilerOptions.baseUrl ? fpath.resolve(root, compilerOptions.baseUrl) : root;
+		paths = compilerOptions.paths;
+	} catch {
+		return [];
+	}
+	if (!paths) return [];
+	const aliases = [];
+	for (const [pattern, targets] of Object.entries(paths)) {
+		const target = targets?.[0];
+		if (!target) continue;
+		if (pattern.endsWith("*")) {
+			const find = pattern.slice(0, -1);
+			const targetDir = target.slice(0, -1);
+			aliases.push({
+				find,
+				replacement: `${fpath.resolve(baseUrl, targetDir)}/`
+			});
+		} else aliases.push({
+			find: pattern,
+			replacement: fpath.resolve(baseUrl, target)
+		});
+	}
+	return aliases;
+}
+/**
+* Strips JSONC comments and trailing commas so `tsconfig.json` (which permits
+* both) can be parsed with `JSON.parse`. String contents are preserved.
+*/
+function stripJsonc(text) {
+	let out = "";
+	for (let i = 0; i < text.length;) {
+		const c = text[i];
+		if (c === "\"" || c === "'") {
+			const quote = c;
+			out += c;
+			i++;
+			while (i < text.length) {
+				if (text[i] === "\\") {
+					out += text[i] + (text[i + 1] ?? "");
+					i += 2;
+					continue;
+				}
+				const cc = text[i++];
+				out += cc;
+				if (cc === quote) break;
+			}
+			continue;
+		}
+		if (c === "/" && text[i + 1] === "/") {
+			i += 2;
+			while (i < text.length && text[i] !== "\n") i++;
+			continue;
+		}
+		if (c === "/" && text[i + 1] === "*") {
+			i += 2;
+			while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++;
+			i += 2;
+			continue;
+		}
+		out += c;
+		i++;
+	}
+	return out.replace(/,(\s*[}\]])/g, "$1");
+}
+//#endregion
+//#region src/site/checkRoutes.ts
+const ENDPOINT_TYPES = [
+	"PageServerEndPoint",
+	"PageEndPoint",
+	"ServerEndPoint",
+	"ServerHook"
+];
+const USAGE_RE = new RegExp(`\\b(satisfies|as|:)\\s*\\b(${ENDPOINT_TYPES.join("|")})\\b`, "g");
+const TYPE_NAME_RE = new RegExp(`^(?:${ENDPOINT_TYPES.join("|")})\\b`);
+/**
+* Checks the route files of a site against their type annotations:
+*
+* - Route path annotations (e.g. `PageServerEndPoint<"/posts/[id]">`) must
+*   match the route derived from the file's location, so types can't silently
+*   lie when files move
+* - Exports that widen the endpoint type (`satisfies T as T`, `as T`, or a
+*   variable annotation) are flagged, because they destroy `PageData` /
+*   `PageForm` / param inference
+* - Routes with dynamic params but no route annotation are flagged, because
+*   their params are loosely typed
+*
+* Only `.ts` route files are checked; annotations are matched by the standard
+* type names (renamed imports are not detected). Best-effort, source-level —
+* comments mentioning these patterns may produce false positives.
+*/
+function checkRoutes(site) {
+	const issues = [];
+	for (const route of site.routes) issues.push(...checkRoute(site, route));
+	return issues;
+}
+/**
+* Checks a single route's file. Returns no issues for routes without a `.ts`
+* file (`.torp` components, inline endpoints, `.js` files).
+*/
+function checkRoute(site, route) {
+	if (!route.file || !route.file.endsWith(".ts")) return [];
+	let source;
+	try {
+		source = readFileSync(fpath.join(site.root, route.file), "utf8");
+	} catch {
+		return [];
+	}
+	return checkRouteSource(source, route.file, expectedAnnotationPath(route), typeNameFor(route));
+}
+/**
+* Checks a single route file's source. Exported for reuse (e.g. re-checking a
+* changed file during dev).
+* @param source The route file's source code
+* @param file The file path, relative to the site root (used in messages)
+* @param expected The route path derived from the file's location
+* @param typeName The endpoint type name conventionally used by this route
+* type (used in suggestions)
+*/
+function checkRouteSource(source, file, expected, typeName) {
+	const issues = [];
+	let sawAnnotation = false;
+	USAGE_RE.lastIndex = 0;
+	for (let m = USAGE_RE.exec(source); m; m = USAGE_RE.exec(source)) {
+		sawAnnotation = true;
+		const kind = m[1];
+		const usedTypeName = m[2];
+		const { routePath, end } = parseTypeArgs(source, m.index + m[0].length);
+		const line = lineOf(source, m.index);
+		if (routePath !== void 0 && routePath !== expected) issues.push({
+			file,
+			line,
+			severity: "error",
+			message: `Route annotation "${routePath}" doesn't match this file's route "${expected}" (derived from its location). Did the file move?`
+		});
+		if (kind === "as" || kind === ":") issues.push({
+			file,
+			line,
+			severity: "warning",
+			message: kind === "as" ? `The \`as ${usedTypeName}\` cast widens the exported type, so PageData/PageForm/param inference falls back to loose types. Use \`satisfies ${usedTypeName}${routePathArg(expected, routePath)}\` without a cast instead.` : `The variable annotation widens the exported type, so PageData/PageForm/param inference falls back to loose types. Use \`satisfies ${usedTypeName}${routePathArg(expected, routePath)}\` on the default export instead.`
+		});
+		else {
+			const cast = parseAsCast(source, end);
+			if (cast) {
+				issues.push({
+					file,
+					line,
+					severity: "warning",
+					message: `The \`as\` cast after \`satisfies\` widens the exported type, so PageData/PageForm/param inference falls back to loose types. Use \`satisfies ${usedTypeName}${routePathArg(expected, routePath ?? cast.routePath)}\` on its own.`
+				});
+				if (cast.routePath !== void 0 && cast.routePath !== expected) issues.push({
+					file,
+					line,
+					severity: "error",
+					message: `Route annotation "${cast.routePath}" doesn't match this file's route "${expected}" (derived from its location). Did the file move?`
+				});
+				USAGE_RE.lastIndex = cast.end;
+			} else if (routePath === void 0 && expected.includes("[")) issues.push({
+				file,
+				line,
+				severity: "warning",
+				message: `No route path on the annotation, so params are loosely typed. Use \`satisfies ${usedTypeName}<"${expected}">\`.`
+			});
+		}
+	}
+	if (!sawAnnotation && file.endsWith(".ts") && expected.includes("[")) issues.push({
+		file,
+		line: 1,
+		severity: "warning",
+		message: `No route annotation, so params are loosely typed. Add \`satisfies ${typeName}<"${expected}">\` to the default export.`
+	});
+	return issues;
+}
+/**
+* Prints issues to the console and returns the number of errors.
+*/
+function reportRouteIssues(issues) {
+	for (const issue of issues) console.error(`[torpor] ${issue.severity}: ${issue.file}:${issue.line} ${issue.message}`);
+	return issues.filter((i) => i.severity === "error").length;
+}
+const MAKE_API_RE = /\bmakeApi\s*<\s*(["'])([^"']+)\1\s*,\s*typeof\s+([A-Za-z_$][\w$]*)/g;
+const DEFAULT_IMPORT_RE = /\bimport\s+(?:type\s+)?([A-Za-z_$][\w$]*)\s+from\s*(["'])([^"']+)\2/g;
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	".git",
+	".torpor",
+	".vite",
+	"coverage"
+]);
+const SOURCE_FILE_RE = /\.(ts|js|torp)$/;
+/**
+* Creates the shared state used by `checkApiCallSource`, so per-file checks
+* (e.g. re-checking a changed file during dev) don't rebuild it.
+*/
+function createApiCallCheck(site) {
+	const routesByFile = /* @__PURE__ */ new Map();
+	for (const route of site.routes) if (route.file) routesByFile.set(route.file.replaceAll("\\", "/"), route);
+	return {
+		root: site.root,
+		routesByFile,
+		aliases: tsconfigAliases(site.root)
+	};
+}
+/**
+* Checks `makeApi<Route, typeof endpoint>` calls across the site's source
+* files: the `Route` argument must match the route derived from the imported
+* endpoint file's location. Calls whose endpoint isn't a type-only import of
+* a known route file are skipped.
+*/
+function checkApiCalls(site) {
+	const check = createApiCallCheck(site);
+	const issues = [];
+	for (const file of walkSourceFiles(site.root)) {
+		let source;
+		try {
+			source = readFileSync(file, "utf8");
+		} catch {
+			continue;
+		}
+		issues.push(...checkApiCallSource(source, file, check));
+	}
+	return issues;
+}
+/**
+* Checks the `makeApi` calls in a single file's source.
+* @param source The file's source code
+* @param file The file's absolute path (used to resolve relative imports and
+* to derive the path shown in messages)
+* @param check Shared state from `createApiCallCheck`
+*/
+function checkApiCallSource(source, file, check) {
+	const imports = /* @__PURE__ */ new Map();
+	for (let m = DEFAULT_IMPORT_RE.exec(source); m; m = DEFAULT_IMPORT_RE.exec(source)) imports.set(m[1], m[3]);
+	const issues = [];
+	for (let m = MAKE_API_RE.exec(source); m; m = MAKE_API_RE.exec(source)) {
+		const specifier = imports.get(m[3]);
+		if (!specifier) continue;
+		const resolved = resolveSpecifier(specifier, file, check);
+		if (!resolved) continue;
+		const relFile = fpath.relative(check.root, resolved).replaceAll("\\", "/");
+		const route = check.routesByFile.get(relFile);
+		if (!route) continue;
+		const expected = expectedAnnotationPath(route);
+		if (m[2] !== expected) issues.push({
+			file: fpath.relative(check.root, file).replaceAll("\\", "/"),
+			line: lineOf(source, m.index),
+			severity: "error",
+			message: `makeApi route "${m[2]}" doesn't match the endpoint's route "${expected}" (derived from ${relFile}). Did the endpoint move?`
+		});
+	}
+	return issues;
+}
+/**
+* Resolves an import specifier to an existing file: relative specifiers are
+* resolved against the importing file, others against tsconfig path aliases.
+* Bare module specifiers that match no alias return undefined.
+*/
+function resolveSpecifier(specifier, fromFile, check) {
+	let candidate;
+	if (specifier.startsWith("./") || specifier.startsWith("../")) candidate = fpath.resolve(fpath.dirname(fromFile), specifier);
+	else for (const alias of check.aliases) if (typeof alias.find === "string") {
+		if (specifier.startsWith(alias.find)) {
+			candidate = fpath.resolve(alias.replacement, specifier.slice(alias.find.length));
+			break;
+		}
+	} else if (alias.find.test(specifier)) {
+		candidate = specifier.replace(alias.find, alias.replacement);
+		break;
+	}
+	if (!candidate) return void 0;
+	const probes = [
+		candidate,
+		`${candidate}.ts`,
+		`${candidate}.js`,
+		fpath.join(candidate, "index.ts"),
+		fpath.join(candidate, "index.js")
+	];
+	for (const probe of probes) if (existsSync(probe) && statSync(probe).isFile()) return probe;
+}
+function walkSourceFiles(root) {
+	const files = [];
+	const visit = (dir) => {
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) if (entry.isDirectory()) {
+			if (!SKIP_DIRS.has(entry.name)) visit(fpath.join(dir, entry.name));
+		} else if (entry.isFile() && SOURCE_FILE_RE.test(entry.name) && !entry.name.endsWith(".d.ts")) files.push(fpath.join(dir, entry.name));
+	};
+	visit(root);
+	return files;
+}
+/**
+* The route path a file's annotation should use, derived from its manifest
+* entry: internal suffixes (`/~server`, `/_layout` etc) are stripped so e.g.
+* `posts/[id]/+page.server.ts` expects `"/posts/[id]"`.
+*/
+function expectedAnnotationPath(route) {
+	let p = route.path;
+	switch (route.type) {
+		case 1:
+			p = p.replace(/\/~server$/, "");
+			break;
+		case 4:
+			p = p.replace(/\/_layout$/, "");
+			break;
+		case 5:
+			p = p.replace(/\/_layout\/~server$/, "");
+			break;
+		case 6:
+			p = p.replace(/\/_hook$/, "");
+			break;
+		case 7:
+			p = p.replace(/\/_hook\/~server$/, "");
+			break;
+		case 8:
+			p = p.replace(/\/_error$/, "");
+			break;
+	}
+	return p === "" ? "/" : p;
+}
+function typeNameFor(route) {
+	switch (route.type) {
+		case 1:
+		case 5: return "PageServerEndPoint";
+		case 3: return "ServerEndPoint";
+		case 6:
+		case 7: return "ServerHook";
+		default: return "PageEndPoint";
+	}
+}
+/**
+* Parses the type arguments that follow an endpoint type name, returning the
+* first argument when it is a string literal (the route path), plus the index
+* after the closing `>` (or after the type name when there are no arguments).
+*/
+function parseTypeArgs(source, start) {
+	let i = start;
+	while (i < source.length && /\s/.test(source[i])) i++;
+	if (source[i] !== "<") return {
+		routePath: void 0,
+		end: i
+	};
+	i++;
+	let depth = 1;
+	let routePath;
+	let seenComma = false;
+	while (i < source.length) {
+		const c = source[i];
+		if (c === "\"" || c === "'") {
+			const quote = c;
+			let j = i + 1;
+			while (j < source.length && source[j] !== quote) {
+				if (source[j] === "\\") j++;
+				j++;
+			}
+			if (routePath === void 0 && !seenComma) routePath = source.slice(i + 1, j);
+			i = j + 1;
+			continue;
+		}
+		if (c === "<") depth++;
+		else if (c === ">") {
+			depth--;
+			if (depth === 0) return {
+				routePath,
+				end: i + 1
+			};
+		} else if (c === "," && routePath === void 0) seenComma = true;
+		i++;
+	}
+	return {
+		routePath,
+		end: i
+	};
+}
+/**
+* Parses an `as T`-style cast that follows a `satisfies T` usage, returning
+* its optional route path argument and the index after the cast.
+*/
+function parseAsCast(source, start) {
+	let i = start;
+	while (i < source.length && /\s/.test(source[i])) i++;
+	if (!/^as\b/.test(source.slice(i, i + 3))) return void 0;
+	i += 2;
+	while (i < source.length && /\s/.test(source[i])) i++;
+	if (!TYPE_NAME_RE.test(source.slice(i))) return void 0;
+	i = i + source.slice(i).match(TYPE_NAME_RE)[0].length;
+	return parseTypeArgs(source, i);
+}
+function routePathArg(expected, actual) {
+	return `<"${actual ?? expected}">`;
+}
+function lineOf(source, index) {
+	let line = 1;
+	for (let i = 0; i < index; i++) if (source[i] === "\n") line++;
+	return line;
+}
+//#endregion
+//#region src/site/checkLayoutSlots.ts
+/**
+* The default import of a `.torp` component from a `.ts`/`.js` route file,
+* e.g. `import component from "@/views/Layout.torp"`.
+*/
+const DEFAULT_TORP_IMPORT_RE = /import\s+[A-Za-z_$][\w$]*\s+from\s*["']([^"']+\.torp)["']/;
+/**
+* Checks that every `_layout` route renders its default `<slot />`.
+*
+* The layout engine composes pages by passing each layout (and finally the
+* page) as the default slot of its parent, so a layout that never renders
+* `<slot />` drops its entire content: the server renders the layout's own
+* markup with an empty content area (no error), and the first client-side
+* navigation that reuses the layout fails on a null slot region.
+*
+* Runs at build time (failing the build) and at dev startup. Best-effort and
+* static: a layout that renders `<slot />` conditionally (inside `@if`)
+* passes here, and is caught at request time by the server render warning
+* (see site/layoutSlots.ts).
+*/
+function checkLayoutSlots(site) {
+	const issues = [];
+	for (const route of site.routes) if (route.type === 4) issues.push(...checkLayoutSlot(site, route));
+	return issues;
+}
+/**
+* Checks a single layout route's component (the `.torp` route file itself,
+* or the `.torp` file its `.ts`/`.js` endpoint re-exports as its default
+* import). Routes without a file (inline endpoints) can't hold a component,
+* so they are skipped.
+*/
+function checkLayoutSlot(site, route) {
+	if (route.type !== 4 || !route.file) return [];
+	const check = createApiCallCheck(site);
+	let torpFile = fpath.join(site.root, route.file);
+	if (!route.file.endsWith(".torp")) {
+		const source = readIfExists(torpFile);
+		if (source === void 0) return [];
+		const match = DEFAULT_TORP_IMPORT_RE.exec(source);
+		if (!match) return [];
+		const resolved = resolveSpecifier(match[1], torpFile, check);
+		if (!resolved) return [];
+		torpFile = resolved;
+	}
+	const source = readIfExists(torpFile);
+	if (source === void 0) return [];
+	const parsed = parse(source);
+	if (!parsed.ok || !parsed.template) return [];
+	if (rendersDefaultSlot(parsed.template)) return [];
+	return [{
+		file: route.file,
+		line: 1,
+		severity: "error",
+		message: "The layout never renders <slot />, so pages under it render without their content. Every _layout component must render <slot />, or pass it down to a child component it renders."
+	}];
+}
+function readIfExists(file) {
+	try {
+		if (!existsSync(file) || !statSync(file).isFile()) return void 0;
+		return readFileSync(file, "utf8");
+	} catch {
+		return;
+	}
+}
+/**
+* Walks a parsed template looking for a default `<slot />` anywhere in the
+* render tree — including nested inside a child component element, which is
+* how a layout passes the page slot down (e.g. `<Shell><slot /></Shell>`).
+*/
+function rendersDefaultSlot(template) {
+	const component = template.components?.[0];
+	if (!component) return false;
+	return walk(component.markup);
+}
+function walk(node) {
+	if ((node.type === "element" || node.type === "special") && node.tagName === "slot" && !node.attributes?.some((a) => a.name === "name")) return true;
+	return (node.children ?? []).some(walk);
+}
+//#endregion
+//#region src/site/manifest.ts
+const moduleId = "@torpor/build/manifest";
+const LOAD_EXPORT_RE = /[{,]\s*load\s*[:(]|\bexport\s+(?:async\s+)?(?:function|const|let|var)\s+load\b|\bexport\s*\{[^}]*\bload\b/;
+function hasLoadExport(source) {
+	return LOAD_EXPORT_RE.test(source);
+}
+/**
+* A Vite plugin that provides information about the app to both clientEntry and
+* serverEntry.
+*/
+function manifest(site, server = false) {
+	return {
+		name: "torpor-manifest",
+		resolveId: {
+			order: "pre",
+			handler(id) {
+				if (id === moduleId) return id;
+			}
+		},
+		load(id, viteOptions) {
+			if (id === moduleId) {
+				let serverRequest = server && !!viteOptions?.ssr;
+				const hasInline = site.routes.some((r) => r.endPoint && !r.file);
+				const hasPlugins = site.plugins.length > 0;
+				const hasOpenApi = site.pluginState.has(OPEN_API_STATE_KEY);
+				const configImport = hasInline || hasPlugins || hasOpenApi ? serverRequest && site.configFile ? `import __site from ${JSON.stringify(site.configFile)};` : "" : "";
+				const pluginLoop = serverRequest && hasPlugins ? `for (const __plugin of __site.plugins ?? []) { await __plugin(__site); }` : "";
+				const openApiOptions = site.pluginState.get(OPEN_API_STATE_KEY);
+				const openApiGlue = serverRequest && openApiOptions && site.configFile ? openApiGlueCode(site, openApiOptions) : "";
+				const openApiRoute = serverRequest && openApiOptions ? `{ path: ${JSON.stringify(openApiOptions.path)}, type: 3, endPoint: () => Promise.resolve({ default: { get: __openApiGet } }), subFolder: undefined },` : "";
+				return `
+${!serverRequest ? "const load = { default: { load: true } };" : ""}
+${configImport}
+${pluginLoop}
+${openApiGlue}
+export default {
+  routes: [
+    ${site.routes.map((r) => {
+					let endPoint;
+					if (!r.file) if (serverRequest) {
+						const key = `${r.path}:${r.type}`;
+						endPoint = `() => Promise.resolve({ default: __site.inlineEndPoints[${JSON.stringify(key)}] })`;
+					} else endPoint = typeof r.endPoint?.load === "function" ? "() => load" : "undefined";
+					else if (serverRequest || !/server\.(ts|js)$/.test(r.file)) {
+						const importExpr = `() => import("${fpath.join(site.root, r.file)}")`;
+						endPoint = r.file.endsWith(".torp") ? `${importExpr}.then((m) => ({ default: { component: m.default } }))` : importExpr;
+					} else endPoint = hasLoadExport(readFileSync(fpath.join(site.root, r.file), "utf8")) ? "() => load" : "undefined";
+					const sub = r.subFolder ? `"${r.subFolder}"` : "undefined";
+					return `{ path: "${r.path}", type: ${r.type}, endPoint: ${endPoint}, subFolder: ${sub} },`;
+				}).join("\n    ")}
+    ${openApiRoute}
+  ],
+};
+`;
+			}
+		}
+	};
+}
+/**
+* Generates the module code for the OpenAPI document endpoint: a map of
+* route path to endpoint loader, and a cached handler that loads every
+* endpoint and builds the document on first use.
+*/
+function openApiGlueCode(site, options) {
+	return `
+import { buildOpenApiDocument, OPEN_API_STATE_KEY } from "@torpor/build/openapi";
+let __openApiDoc;
+const __openApiRoutes = {
+    ${site.routes.filter((r) => r.type === 3).filter((r) => r.path !== options.docs).map((r) => {
+		if (!r.file) {
+			const key = `${r.path}:${r.type}`;
+			return `${JSON.stringify(r.path)}: () => Promise.resolve({ default: __site.inlineEndPoints[${JSON.stringify(key)}] })`;
+		}
+		const filePath = fpath.join(site.root, r.file);
+		return `${JSON.stringify(r.path)}: () => import(${JSON.stringify(filePath)})`;
+	}).join(",\n    ")}
+};
+async function __openApiGet() {
+    if (!__openApiDoc) {
+        const __entries = [];
+        for (const [__path, __loader] of Object.entries(__openApiRoutes)) {
+            __entries.push({ path: __path, endPoint: (await __loader()).default });
+        }
+        __openApiDoc = buildOpenApiDocument(__entries, __site.pluginState.get(OPEN_API_STATE_KEY));
+    }
+    return new Response(JSON.stringify(__openApiDoc), {
+        headers: { "Content-Type": "application/json" },
+    });
+}
+`;
+}
+//#endregion
+//#region src/utils/torporPackages.ts
+/**
+* Finds packages installed in the site that ship `.torp` files, e.g. icon
+* libraries like phosphor-torpor. These packages need the torpor compiler, so
+* they can't go through Vite's default pipelines: dep optimization parses
+* their files as plain JavaScript (and fails on torpor syntax like `@render`
+* or `import type` from an uncompiled source), and SSR externalization would
+* leave raw `.torp` imports that neither Node nor workerd can load.
+*
+* A package is a torpor package when it declares a `torpor` entry in its
+* package.json (e.g. `"torpor": "./lib/index.js"`, mirroring the `svelte`
+* field convention), or when any of its export targets is a `.torp` file.
+*
+* @param siteRoot The root folder of the site
+* @returns The names of the torpor packages found (may be empty)
+*/
+function findTorporPackages(siteRoot) {
+	const sitePackageJson = fpath.resolve(siteRoot, "package.json");
+	if (!existsSync(sitePackageJson)) return [];
+	const pkg = JSON.parse(readFileSync(sitePackageJson, "utf8"));
+	const packages = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const rootRequire = createRequire(sitePackageJson);
+	for (const name of dependencyNames$1(pkg)) collectTorporPackage(name, rootRequire, packages, visited);
+	return [...packages];
+}
+/**
+* Adds `optimizeDeps.exclude` and `ssr.noExternal` entries for packages that
+* ship `.torp` files, so that they are served/bundled through the torpor
+* compiler instead.
+*/
+function addTorporPackageConfig(siteRoot, config) {
+	const packages = findTorporPackages(siteRoot);
+	if (packages.length === 0) return;
+	config.optimizeDeps ??= {};
+	config.optimizeDeps.exclude = [...config.optimizeDeps.exclude ?? [], ...packages];
+	config.ssr ??= {};
+	const noExternal = config.ssr.noExternal;
+	if (noExternal === void 0) config.ssr.noExternal = packages;
+	else if (Array.isArray(noExternal)) noExternal.push(...packages);
+}
+function dependencyNames$1(pkg) {
+	return [
+		...Object.keys(pkg.dependencies ?? {}),
+		...Object.keys(pkg.devDependencies ?? {}),
+		...Object.keys(pkg.optionalDependencies ?? {}),
+		...Object.keys(pkg.peerDependencies ?? {})
+	];
+}
+function collectTorporPackage(name, require, packages, visited) {
+	if (isBuiltin(name)) return;
+	const packageJsonPath = resolvePackageJson(name, require);
+	if (!packageJsonPath || visited.has(packageJsonPath)) return;
+	visited.add(packageJsonPath);
+	let pkg;
+	try {
+		pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+	} catch {
+		return;
+	}
+	if (isTorporPackage(pkg)) packages.add(pkg.name ?? name);
+	const depRequire = createRequire(packageJsonPath);
+	for (const depName of dependencyNames$1(pkg)) collectTorporPackage(depName, depRequire, packages, visited);
+}
+function isTorporPackage(pkg) {
+	if (typeof pkg.torpor === "string") return true;
+	return exportsIncludeTorp(pkg.exports);
+}
+function exportsIncludeTorp(exports) {
+	if (typeof exports === "string") return exports.endsWith(".torp");
+	if (Array.isArray(exports)) return exports.some(exportsIncludeTorp);
+	if (exports && typeof exports === "object") return Object.values(exports).some(exportsIncludeTorp);
+	return false;
+}
+function resolvePackageJson(name, require) {
+	try {
+		const packageJson = require.resolve(`${name}/package.json`);
+		return fpath.isAbsolute(packageJson) ? packageJson : void 0;
+	} catch {
+		let entry;
+		try {
+			entry = require.resolve(name);
+		} catch {
+			return;
+		}
+		if (!fpath.isAbsolute(entry)) return void 0;
+		let dir = fpath.dirname(entry);
+		while (true) {
+			const packageJson = fpath.join(dir, "package.json");
+			if (existsSync(packageJson)) return packageJson;
+			const parent = fpath.dirname(dir);
+			if (parent === dir) return void 0;
+			dir = parent;
+		}
+	}
+}
+//#endregion
+//#region src/run/runBuild.ts
+async function runBuild(site) {
+	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)`);
+	const distFolder = fpath.resolve(site.root, "dist");
+	if (existsSync(distFolder)) await promises.rm(distFolder, { recursive: true });
+	const clientFolder = fpath.join(distFolder, "client");
+	const serverFolder = fpath.join(distFolder, "server");
+	if (site.adapter.prebuild) await site.adapter.prebuild(site);
+	const siteHtml = fpath.resolve(site.root, "src/site.html");
+	const hasSiteHtml = existsSync(siteHtml);
+	const siteFolder = fpath.resolve(site.root, "./node_modules/@torpor/build/src/site/");
+	let clientScript = fpath.join(siteFolder, "clientEntry.ts");
+	let serverScript = fpath.join(siteFolder, "serverEntry.ts");
+	const clientConfig = structuredClone(site.viteConfig ?? {});
+	clientConfig.resolve ??= {};
+	clientConfig.resolve.tsconfigPaths ??= true;
+	clientConfig.resolve.alias = [...asAliasArray$1(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) => fpath.resolve(site.root, r.file)),
+		...site.inputs.filter((f) => !/server\.(ts|js)$/.test(f))
+	];
+	clientConfig.build.ssrManifest = true;
+	await build(defineConfig(clientConfig));
+	const serverConfig = structuredClone(site.viteConfig ?? {});
+	serverConfig.resolve ??= {};
+	serverConfig.resolve.tsconfigPaths ??= true;
+	serverConfig.resolve.alias = [...asAliasArray$1(serverConfig.resolve.alias), ...tsconfigAliases(site.root)];
+	serverConfig.plugins = [
+		manifest(site, true),
+		torpor(),
+		...site.vitePlugins
+	];
+	serverConfig.build ??= {};
+	serverConfig.build.outDir = serverFolder;
+	addTorporPackageConfig(site.root, serverConfig);
+	serverConfig.build.rollupOptions ??= {};
+	serverConfig.build.rollupOptions.input = [
+		serverScript,
+		...site.routes.filter((r) => r.file).map((r) => fpath.resolve(site.root, r.file)),
+		...site.inputs
+	];
+	serverConfig.build.ssr = serverScript;
+	await build(defineConfig(serverConfig));
+	if (hasSiteHtml) {
+		await promises.rename(fpath.join(clientFolder, "src", "site.html"), fpath.join(clientFolder, "site.html"));
+		await promises.rm(fpath.join(clientFolder, "src"), { recursive: true });
+	}
+	if (site.adapter.postbuild) await site.adapter.postbuild(site);
+}
+function asAliasArray$1(alias) {
+	if (!alias) return [];
+	if (Array.isArray(alias)) return alias;
+	return Object.entries(alias).map(([find, replacement]) => ({
+		find,
+		replacement
+	}));
+}
+//#endregion
+//#region src/run/prepareTemplate.ts
+function prepareTemplate(template, clientScript, clientDevScript) {
+	let result = template;
+	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);
+	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);
+	if (clientDevScript) result += `<script type="module" src="${clientDevScript}"><\/script>`;
+	result += `<script type="module" src="${clientScript}"><\/script>`;
+	return result;
+}
+function regexIndexOf(string, regex, position) {
+	var indexOf = string.substring(position || 0).search(regex);
+	return indexOf >= 0 ? indexOf + (position || 0) : indexOf;
+}
+//#endregion
+//#region src/run/devPlugin.ts
+/**
+* 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.
+*/
+function devPlugin(site) {
+	return {
+		name: "torpor-dev",
+		configureServer(vite) {
+			const handlerPromise = createDevHandler(vite, site);
+			return () => {
+				vite.middlewares.use(async (req, res, next) => {
+					try {
+						await (await handlerPromise)(req, res);
+					} catch (e) {
+						next(e);
+					}
+				});
+			};
+		}
+	};
+}
+async function createDevHandler(vite, site) {
+	const siteFolder = fpath.resolve(site.root, "./node_modules/@torpor/build/src/site/");
+	const serverScript = fpath.join(siteFolder, "serverEntry.ts");
+	let template;
+	const templateFile = fpath.resolve(site.root, "src/site.html");
+	if (existsSync(templateFile)) {
+		template = await promises.readFile(templateFile, "utf-8");
+		template = await vite.transformIndexHtml("", template);
+		const clientScript = fpath.join(siteFolder, "clientEntry.ts");
+		const clientDevScript = fpath.join(siteFolder, "clientEntryDev.ts");
+		template = prepareTemplate(template, clientScript, clientDevScript);
+	}
+	const server = new Server();
+	server.add("*", async (ev) => {
+		try {
+			const { load } = await vite.ssrLoadModule(serverScript);
+			return await load(ev, template);
+		} catch (e) {
+			vite.ssrFixStacktrace(e);
+			return serverError(e);
+		}
+	});
+	globalThis.adapter = { env: process.env };
+	return async (req, res) => {
+		const request = await nodeReqToRequest(req);
+		await sendResponse(await server.fetch(request), res);
+	};
+}
+async function nodeReqToRequest(req) {
+	const url = req.url ?? "/";
+	const host = req.headers.host ?? "localhost";
+	const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https" : "http";
+	const init = {
+		method: req.method,
+		headers: flattenHeaders(req.headers)
+	};
+	if (req.method !== "GET" && req.method !== "HEAD") {
+		init.body = Readable.toWeb(req);
+		init.duplex = "half";
+	}
+	return new Request(`${protocol}://${host}${url}`, init);
+}
+async function sendResponse(response, res) {
+	res.statusCode = response.status;
+	response.headers.forEach((value, key) => res.setHeader(key, value));
+	if (!response.body) {
+		res.end();
+		return;
+	}
+	Readable.fromWeb(response.body).pipe(res);
+}
+//#endregion
+//#region src/run/depCache.ts
+/**
+* Vite's dep-optimization cache (node_modules/.vite) keys off the lockfile
+* and config, but not the content of workspace packages. When a workspace
+* package is rebuilt while the cache holds prebundled copies of it, dev SSR
+* keeps executing the stale modules -- producing bizarre errors (missing
+* runtime identifiers, "$cache must be used in a getter", ...) that only a
+* manual cache delete fixes.
+*
+* clearStaleDepCache runs at `tb --dev` startup: it fingerprints every
+* workspace package the site depends on (path, size and mtime of each file)
+* and, when the fingerprint differs from the previous run, deletes the cache
+* so Vite re-optimizes from the rebuilt packages.
+*
+* Live rebuilds while the server is up are still not hot-invalidated (that
+* needs a watcher feeding Vite's module graph); this closes the "restart and
+* hope you remember the trick" gap.
+*/
+const STORE_NAME = ".torpor-dev-cache.json";
+/**
+* Clears site/node_modules/.vite when workspace packages changed since the
+* last dev run. Returns true when the cache was removed.
+*/
+function clearStaleDepCache(siteRoot, log) {
+	try {
+		const workspaceRoot = findWorkspaceRoot(siteRoot);
+		if (!workspaceRoot) return false;
+		const cacheDir = fpath.join(siteRoot, "node_modules", ".vite");
+		const storePath = fpath.join(siteRoot, "node_modules", STORE_NAME);
+		const fingerprint = fingerprintWorkspacePackages(siteRoot, workspaceRoot);
+		if (fingerprint === void 0) return false;
+		const previous = readStore(storePath);
+		let cleared = false;
+		if (existsSync(cacheDir) && previous !== fingerprint) {
+			rmSync(cacheDir, {
+				recursive: true,
+				force: true
+			});
+			cleared = true;
+			log?.("Workspace packages changed; clearing the Vite dep cache");
+		}
+		writeFileSync(storePath, JSON.stringify({ fingerprint }));
+		return cleared;
+	} catch (e) {
+		if (process.env.TORPOR_DEBUG_CACHE) throw e;
+		return false;
+	}
+}
+function findWorkspaceRoot(from) {
+	let dir = fpath.resolve(from);
+	while (true) {
+		if (existsSync(fpath.join(dir, "pnpm-workspace.yaml"))) return dir;
+		if (hasWorkspacesField(dir)) return dir;
+		const parent = fpath.dirname(dir);
+		if (parent === dir) return void 0;
+		dir = parent;
+	}
+}
+function hasWorkspacesField(dir) {
+	const packageJsonPath = fpath.join(dir, "package.json");
+	if (!existsSync(packageJsonPath)) return false;
+	try {
+		const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+		return Array.isArray(pkg.workspaces) && pkg.workspaces.length > 0;
+	} catch {
+		return false;
+	}
+}
+function readStore(storePath) {
+	if (!existsSync(storePath)) return void 0;
+	try {
+		return JSON.parse(readFileSync(storePath, "utf8")).fingerprint;
+	} catch {
+		return;
+	}
+}
+/**
+* Resolves every site dependency that lives inside the workspace to its
+* package folder. Shared with the other dev-startup checks (e.g. the stale
+* .torp copy report), which need the same set of packages.
+*/
+function workspaceDependencyDirs(siteRoot, workspaceRoot) {
+	const sitePackageJson = fpath.join(siteRoot, "package.json");
+	if (!existsSync(sitePackageJson)) return [];
+	const pkg = JSON.parse(readFileSync(sitePackageJson, "utf8"));
+	const require = createRequire(sitePackageJson);
+	const packageDirs = /* @__PURE__ */ new Set();
+	for (const name of dependencyNames(pkg)) {
+		const dir = resolvePackageDir(name, require);
+		if (dir && insideWorkspace(realpathSync(dir), workspaceRoot)) packageDirs.add(realpathSync(dir));
+	}
+	return [...packageDirs].sort();
+}
+function fingerprintWorkspacePackages(siteRoot, workspaceRoot) {
+	if (!existsSync(fpath.join(siteRoot, "package.json"))) return void 0;
+	const packageDirs = workspaceDependencyDirs(siteRoot, workspaceRoot);
+	if (packageDirs.length === 0) return void 0;
+	const hash = createHash("sha1");
+	for (let dir of packageDirs) {
+		hash.update(`package:${dir}\n`);
+		fingerprintDir(dir, dir, hash);
+	}
+	return hash.digest("hex");
+}
+function dependencyNames(pkg) {
+	return [...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})];
+}
+function resolvePackageDir(name, require) {
+	try {
+		const packageJsonPath = require.resolve(`${name}/package.json`);
+		return fpath.dirname(packageJsonPath);
+	} catch {
+		return;
+	}
+}
+function insideWorkspace(dir, workspaceRoot) {
+	const relative = fpath.relative(workspaceRoot, dir);
+	return relative === "" || !relative.startsWith("..") && !fpath.isAbsolute(relative);
+}
+function fingerprintDir(dir, root, hash) {
+	for (let entry of readdirSync(dir, { withFileTypes: true })) {
+		if (entry.name === "node_modules" || entry.name === ".git") continue;
+		const full = fpath.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			fingerprintDir(full, root, hash);
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		const stats = statSync(full);
+		hash.update(`file:${fpath.relative(root, full).replaceAll("\\", "/")}:${stats.size}:${Math.floor(stats.mtimeMs)}\n`);
+	}
+}
+//#endregion
+//#region src/run/staleTorpCopies.ts
+/**
+* Workspace packages that ship copies of their .torp components (e.g.
+* @torpor/ui copies its src .torp files into dist/ during its build) can go
+* stale: a site resolves the package to its dist folder, so edits to src
+* silently keep serving the OLD components until the package is rebuilt.
+* The symptom is confusing -- e.g. a TypeError about a renamed slot prop
+* after a component's API changed.
+*
+* reportStaleTorpCopies runs at `tb --dev` startup: for every workspace
+* dependency with both src and dist folders, it compares the .torp files and
+* reports anything missing from dist, differing from src, or left over in
+* dist without a src file.
+*/
+/**
+* Reports stale dist .torp copies in the site's workspace dependencies.
+* Never throws -- a broken check must not break dev startup.
+*/
+function reportStaleTorpCopies(siteRoot, log) {
+	try {
+		const workspaceRoot = findWorkspaceRoot(siteRoot);
+		if (!workspaceRoot) return;
+		for (const dir of workspaceDependencyDirs(siteRoot, workspaceRoot)) {
+			const srcFolder = fpath.join(dir, "src");
+			const distFolder = fpath.join(dir, "dist");
+			if (!existsSync(srcFolder) || !existsSync(distFolder)) continue;
+			const src = collectTorpFiles(srcFolder);
+			const dist = collectTorpFiles(distFolder);
+			if (src.size === 0 && dist.size === 0) continue;
+			const problems = [];
+			for (const [rel, content] of src) {
+				const distContent = dist.get(rel);
+				if (distContent === void 0) problems.push(`${rel} (not copied to dist)`);
+				else if (distContent !== content) problems.push(`${rel} (differs from src)`);
+			}
+			for (const rel of dist.keys()) if (!src.has(rel)) problems.push(`${rel} (left over in dist, no src file)`);
+			if (problems.length === 0) continue;
+			const shown = problems.slice(0, 5).map((p) => `  ${p}`).join("\n");
+			const more = problems.length > 5 ? `\n  ... and ${problems.length - 5} more` : "";
+			log?.(`${packageLabel(dir, workspaceRoot)}'s dist .torp copies are stale, so the site is serving OLD components:\n${shown}${more}\nRebuild the package (e.g. \`pnpm build\` in ${fpath.relative(workspaceRoot, dir) || "."}) and restart \`tb --dev\`.`);
+		}
+	} catch (e) {
+		if (process.env.TORPOR_DEBUG_CACHE) throw e;
+	}
+}
+function collectTorpFiles(folder) {
+	const files = /* @__PURE__ */ new Map();
+	collect(folder, folder, files);
+	return files;
+}
+function collect(folder, root, files) {
+	for (const entry of readdirSync(folder, { withFileTypes: true })) {
+		if (entry.name === "node_modules" || entry.name === ".git") continue;
+		const full = fpath.join(folder, entry.name);
+		if (entry.isDirectory()) {
+			collect(full, root, files);
+			continue;
+		}
+		if (!entry.isFile() || !entry.name.endsWith(".torp")) continue;
+		files.set(fpath.relative(root, full).replaceAll("\\", "/"), readFileSync(full, "utf8"));
+	}
+}
+function packageLabel(dir, workspaceRoot) {
+	try {
+		const pkg = JSON.parse(readFileSync(fpath.join(dir, "package.json"), "utf8"));
+		if (pkg.name) return pkg.name;
+	} catch {}
+	return fpath.relative(workspaceRoot, dir) || dir;
+}
+//#endregion
+//#region src/run/runDev.ts
+async function runDev(site) {
+	const config = structuredClone(site.viteConfig ?? {});
+	config.appType = "custom";
+	config.server ??= {};
+	config.server.host ??= "localhost";
+	config.server.port ??= 7059;
+	config.resolve ??= {};
+	config.resolve.tsconfigPaths ??= true;
+	config.resolve.conditions ??= [];
+	config.resolve.conditions.push("development");
+	config.resolve.alias = [...asAliasArray(config.resolve.alias), ...tsconfigAliases(site.root)];
+	const adapterDev = site.adapter.dev?.(site);
+	const devPlugins = normalizePlugins(adapterDev ?? devPlugin(site));
+	config.plugins = [
+		manifest(site, true),
+		torpor({ dev: true }),
+		...devPlugins,
+		...site.vitePlugins
+	];
+	config.optimizeDeps ??= {};
+	config.optimizeDeps.extensions ??= [];
+	config.optimizeDeps.extensions.push(".torp");
+	config.optimizeDeps.rolldownOptions ??= {};
+	config.optimizeDeps.rolldownOptions.plugins ??= [estorpor()];
+	addTorporPackageConfig(site.root, config);
+	clearStaleDepCache(site.root, (message) => console.log(`\n${message}`));
+	reportStaleTorpCopies(site.root, (message) => console.log(`\n${message}`));
+	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 createServer(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, vite) {
+	reportRouteIssues(checkRoutes(site));
+	reportRouteIssues(checkApiCalls(site));
+	reportRouteIssues(checkLayoutSlots(site));
+	const routeFiles = new Map(site.routes.filter((r) => r.file?.endsWith(".ts") || r.file?.endsWith(".torp") && r.type === 4).map((r) => [fpath.resolve(site.root, r.file), r]));
+	const apiCheck = createApiCallCheck(site);
+	const reported = /* @__PURE__ */ new Map();
+	const report = (file, issues) => {
+		const key = JSON.stringify(issues);
+		if (reported.get(file) === key) return;
+		reported.set(file, key);
+		reportRouteIssues(issues);
+	};
+	const recheck = (file) => {
+		const route = routeFiles.get(file);
+		if (route) {
+			report(file, route.type === 4 ? checkLayoutSlot(site, route) : checkRoute(site, route));
+			return;
+		}
+		if (!/\.(ts|js|torp)$/.test(file)) return;
+		let source;
+		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) {
+	if (!plugins) return [];
+	return Array.isArray(plugins) ? plugins : [plugins];
+}
+function asAliasArray(alias) {
+	if (!alias) return [];
+	if (Array.isArray(alias)) return alias;
+	return Object.entries(alias).map(([find, replacement]) => ({
+		find,
+		replacement
+	}));
+}
+//#endregion
+//#region src/server/contentType.ts
+function contentType(extension) {
+	return types[extension] || "application/octet-stream";
+}
+const types = {
+	".aac": "audio/aac",
+	".abw": "application/x-abiword",
+	".apng": "image/apng",
+	".arc": "application/x-freearc",
+	".avif": "image/avif",
+	".avi": "video/x-msvideo",
+	".azw": "application/vnd.amazon.ebook",
+	".bin": "application/octet-stream",
+	".bmp": "image/bmp",
+	".bz": "application/x-bzip",
+	".bz2": "application/x-bzip2",
+	".cda": "application/x-cdf",
+	".csh": "application/x-csh",
+	".css": "text/css",
+	".csv": "text/csv",
+	".doc": "application/msword",
+	".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	".eot": "application/vnd.ms-fontobject",
+	".epub": "application/epub+zip",
+	".gz": "application/gzip",
+	".gif": "image/gif",
+	".htm": "text/html",
+	".html": "text/html",
+	".ico": "image/vnd.microsoft.icon",
+	".ics": "text/calendar",
+	".jar": "application/java-archive",
+	".jpeg": "image/jpeg",
+	".jpg": "image/jpeg",
+	".js": "text/javascript",
+	".json": "application/json",
+	".jsonld": "application/ld+json",
+	".mid": "audio/midi",
+	".midi": "audio/midi",
+	".mjs": "text/javascript",
+	".mp3": "audio/mpeg",
+	".mp4": "video/mp4",
+	".mpeg": "video/mpeg",
+	".mpkg": "application/vnd.apple.installer+xml",
+	".odp": "application/vnd.oasis.opendocument.presentation",
+	".ods": "application/vnd.oasis.opendocument.spreadsheet",
+	".odt": "application/vnd.oasis.opendocument.text",
+	".oga": "audio/ogg",
+	".ogv": "video/ogg",
+	".ogx": "application/ogg",
+	".opus": "audio/ogg",
+	".otf": "font/otf",
+	".png": "image/png",
+	".pdf": "application/pdf",
+	".php": "application/x-httpd-php",
+	".ppt": "application/vnd.ms-powerpoint",
+	".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	".rar": "application/vnd.rar",
+	".rtf": "application/rtf",
+	".sh": "application/x-sh",
+	".svg": "image/svg+xml",
+	".tar": "application/x-tar",
+	".tif": "image/tiff",
+	".tiff": "image/tiff",
+	".ts": "video/mp2t",
+	".ttf": "font/ttf",
+	".txt": "text/plain",
+	".vsd": "application/vnd.visio",
+	".wav": "audio/wav",
+	".weba": "audio/webm",
+	".webm": "video/webm",
+	".webp": "image/webp",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".xhtml": "application/xhtml+xml",
+	".xls": "application/vnd.ms-excel",
+	".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	".xml": "application/xml",
+	".xul": "application/vnd.mozilla.xul+xml",
+	".zip": "application/zip",
+	".3gp": "video/3gpp",
+	".3g2": "video/3gpp2",
+	".7z": "application/x-7z-compressed"
+};
+//#endregion
+//#region src/run/runPreview.ts
+async function runPreview(site) {
+	await runBuild(site);
+	const distFolder = fpath.resolve(site.root, "dist");
+	const clientFolder = fpath.join(distFolder, "client");
+	const serverFolder = fpath.join(distFolder, "server");
+	let template;
+	const siteHtml = fpath.join(clientFolder, "site.html");
+	if (existsSync(siteHtml)) {
+		let clientScript = (await promises.readdir(fpath.join(clientFolder, "assets"))).find((f) => f.startsWith("clientEntry-"));
+		if (!clientScript) throw new Error("clientEntry.js not found");
+		clientScript = `/assets/${clientScript}`;
+		template = await promises.readFile(siteHtml, "utf-8");
+		template = prepareTemplate(template, clientScript);
+	}
+	const server = new Server();
+	server.add("/assets/*", async (ev) => {
+		try {
+			const url = new URL(ev.request.url);
+			const file = fpath.join(site.root, "dist", "client", url.pathname);
+			if (existsSync(file)) {
+				const body = await promises.readFile(file);
+				return new Response(body, {
+					status: 200,
+					headers: { "Content-Type": contentType(fpath.extname(file)) }
+				});
+			}
+		} catch (e) {
+			return serverError(e);
+		}
+	});
+	const serverScript = fpath.resolve(serverFolder, "serverEntry.js");
+	server.add("*", async (ev) => {
+		try {
+			const { load } = await import(serverScript);
+			return await load(ev, template);
+		} catch (e) {
+			return serverError(e);
+		}
+	});
+	configDotenv();
+	process.env.PROTOCOL ??= "http:";
+	process.env.HOST ??= "localhost";
+	process.env.PORT ??= "7059";
+	site.adapter.serve(server, site);
+}
+//#endregion
+//#region src/run/run.ts
+/**
+* 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.
+*/
+async function loadSite(folder) {
+	const jsConfigFile = fpath.join(folder, "site.config.js");
+	const tsConfigFile = fpath.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");
+	const vite = await createServer({
+		server: { middlewareMode: true },
+		appType: "custom",
+		resolve: { tsconfigPaths: true },
+		optimizeDeps: { noDiscovery: true }
+	});
+	try {
+		const site = (await vite.ssrLoadModule(configFile)).default;
+		site.configFile = configFile;
+		if (!site || !site.root || !site.routes) throw new Error("Invalid site in config file");
+		for (const plugin of site.plugins) await plugin(site);
+		return {
+			site,
+			vite
+		};
+	} catch (error) {
+		await vite.close();
+		throw error;
+	}
+}
+async function run(folder, mode) {
+	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();
+	}
+}
+//#endregion
+//#region src/run/runOpenApi.ts
+/**
+* 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.
+*/
+async function runOpenApi(site, vite, outFile = "openapi.json") {
+	const options = site.pluginState.get(OPEN_API_STATE_KEY);
+	if (!options) throw new Error("No OpenAPI options found. Add the openApi() plugin to site.plugins to use \"tb --openapi\"");
+	const entries = [];
+	for (const route of site.routes) {
+		if (route.type !== 3) continue;
+		if (options.docs && route.path === options.docs) continue;
+		if (route.endPoint && !route.file) entries.push({
+			path: route.path,
+			endPoint: route.endPoint
+		});
+		else if (route.file) {
+			const file = fpath.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(fpath.resolve(site.root, outFile), JSON.stringify(doc, null, 2) + "\n");
+	console.log(`OpenAPI document written to ${outFile} (${Object.keys(doc.paths ?? {}).length} paths)`);
+}
+//#endregion
+export { runDev as a, runPreview as i, loadSite as n, runBuild as o, run as r, runOpenApi as t };
+
+//# sourceMappingURL=runOpenApi-BUi1RH1l.mjs.map