nitro 3.0.260429-beta → 3.0.260522-beta

package/dist/_build/vite.env.mjs

@@ -0,0 +1,177 @@
+import { isAbsolute as isAbsolute$1, resolveModulePath } from "./common.mjs";
+import { runtimeDependencies, runtimeDir } from "nitro/meta";
+import { join, resolve } from "node:path";
+import { RunnerManager, loadRunner } from "env-runner";
+function createNitroEnvironment(ctx) {
+	const isWorkerdRunner = _isWorkerdRunner(ctx);
+	return {
+		consumer: "server",
+		build: {
+			rollupOptions: ctx.bundlerConfig.rollupConfig,
+			rolldownOptions: ctx.bundlerConfig.rolldownConfig,
+			minify: ctx.nitro.options.minify,
+			emptyOutDir: false,
+			sourcemap: ctx.nitro.options.sourcemap,
+			commonjsOptions: ctx.nitro.options.commonJS,
+			copyPublicDir: false
+		},
+		resolve: {
+			noExternal: ctx.nitro.options.dev ? isWorkerdRunner ? true : [
+				/^nitro$/,
+				new RegExp(`^(${runtimeDependencies.join("|")})$`),
+				...ctx.bundlerConfig.base.noExternal
+			] : true,
+			conditions: isWorkerdRunner ? [
+				"workerd",
+				"worker",
+				...ctx.nitro.options.exportConditions.filter((c) => c !== "node")
+			] : ctx.nitro.options.exportConditions,
+			externalConditions: ctx.nitro.options.exportConditions?.filter((c) => !/browser|wasm|module/.test(c))
+		},
+		define: { "process.env.NODE_ENV": JSON.stringify(ctx.nitro.options.dev ? "development" : "production") },
+		dev: { createEnvironment: async (envName, envConfig) => {
+			const entry = resolve(runtimeDir, "internal/vite/dev-entry.mjs");
+			const { createFetchableDevEnvironment } = await import("./vite.dev.mjs");
+			const env = createFetchableDevEnvironment(envName, envConfig, getEnvRunner(ctx), entry, { preventExternalize: isWorkerdRunner });
+			ctx._transformRequest = (id) => env.transformRequest(id);
+			(ctx._viteEnvs ??= /* @__PURE__ */ new Map()).set(envName, entry);
+			return env;
+		} }
+	};
+}
+function createServiceEnvironment(ctx, name, serviceConfig) {
+	const isWorkerdRunner = _isWorkerdRunner(ctx);
+	return {
+		consumer: "server",
+		build: {
+			rollupOptions: {
+				input: { index: serviceConfig.entry },
+				external: [/^nitro(\/|$)/]
+			},
+			minify: ctx.nitro.options.minify,
+			sourcemap: ctx.nitro.options.sourcemap,
+			outDir: join(ctx.nitro.options.buildDir, "vite/services", name),
+			emptyOutDir: true,
+			copyPublicDir: false
+		},
+		resolve: {
+			...isWorkerdRunner ? { noExternal: true } : {},
+			conditions: isWorkerdRunner ? [
+				"workerd",
+				"worker",
+				...ctx.nitro.options.exportConditions.filter((c) => c !== "node")
+			] : ctx.nitro.options.exportConditions,
+			externalConditions: ctx.nitro.options.exportConditions?.filter((c) => !/browser|wasm|module/.test(c))
+		},
+		dev: { createEnvironment: async (envName, envConfig) => {
+			const entry = tryResolve(serviceConfig.entry);
+			(ctx._viteEnvs ??= /* @__PURE__ */ new Map()).set(envName, entry);
+			const { createFetchableDevEnvironment } = await import("./vite.dev.mjs");
+			return createFetchableDevEnvironment(envName, envConfig, getEnvRunner(ctx), entry, { preventExternalize: isWorkerdRunner });
+		} }
+	};
+}
+function createServiceEnvironments(ctx) {
+	return Object.fromEntries(Object.entries(ctx.services).map(([name, config]) => [name, createServiceEnvironment(ctx, name, config)]));
+}
+async function initEnvRunner(ctx) {
+	if (ctx._envRunner) return ctx._envRunner;
+	if (!ctx._initPromise) ctx._initPromise = (async () => {
+		const manager = new RunnerManager();
+		let _retries = 0;
+		manager.onClose((_runner, cause) => {
+			if (_retries++ < 3) {
+				ctx.nitro.logger.info("Restarting env runner...", cause ? `Cause: ${cause}` : "");
+				_loadRunner(ctx, manager);
+			} else ctx.nitro.logger.error("Env runner failed after 3 retries.", cause ? `Last cause: ${cause}` : "");
+		});
+		manager.onReady(() => {
+			_retries = 0;
+			if (ctx._viteEnvs) for (const [name, entry] of ctx._viteEnvs) manager.sendMessage({
+				type: "custom",
+				event: "nitro:vite-env",
+				data: {
+					name,
+					entry
+				}
+			});
+		});
+		await _loadRunner(ctx, manager);
+		ctx._envRunner = manager;
+		return manager;
+	})();
+	return await ctx._initPromise;
+}
+function getEnvRunner(ctx) {
+	if (!ctx._envRunner) throw new Error("Env runner not initialized. Call initEnvRunner() first.");
+	return ctx._envRunner;
+}
+async function _loadRunner(ctx, manager) {
+	const runnerName = ctx.nitro.options.devServer.runner || process.env.NITRO_DEV_RUNNER || "node-worker";
+	const entry = resolve(runtimeDir, "internal/vite/dev-worker.mjs");
+	let runner;
+	if (runnerName === "miniflare") {
+		const { MiniflareEnvRunner } = await import("env-runner/runners/miniflare");
+		runner = new MiniflareEnvRunner({
+			name: "nitro-vite",
+			data: { entry }
+		});
+	} else runner = await loadRunner(runnerName, {
+		name: "nitro-vite",
+		data: { entry }
+	});
+	await manager.reload(runner);
+}
+const NITRO_PROXY_PREFIX = "\0nitro-env-proxy:";
+function nitroServiceProxy() {
+	return {
+		name: "nitro:service-proxy",
+		enforce: "pre",
+		applyToEnvironment: (env) => env.name !== "nitro" && env.config.consumer === "server",
+		apply: (_config, configEnv) => configEnv.command === "serve",
+		resolveId: {
+			filter: { id: /^nitro(\/|$)/ },
+			handler(id) {
+				if (id === "nitro" || id.startsWith("nitro/")) return {
+					id: NITRO_PROXY_PREFIX + id,
+					moduleSideEffects: false
+				};
+			}
+		},
+		load: {
+			filter: { id: /^\0nitro-env-proxy:/ },
+			handler(id) {
+				if (!id.startsWith(NITRO_PROXY_PREFIX)) return;
+				const originalId = id.slice(17);
+				return {
+					code: [
+						`const _mod = await globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__("nitro", ${JSON.stringify(originalId)});`,
+						`__vite_ssr_exportAll__(_mod);`,
+						`export default _mod.default;`
+					].join("\n"),
+					map: null
+				};
+			}
+		}
+	};
+}
+function _isWorkerdRunner(ctx) {
+	return (ctx.nitro.options.devServer.runner || process.env.NITRO_DEV_RUNNER || "node-worker") === "miniflare";
+}
+function tryResolve(id) {
+	if (/^[~#/\0]/.test(id) || isAbsolute$1(id)) return id;
+	return resolveModulePath(id, {
+		suffixes: ["", "/index"],
+		extensions: [
+			"",
+			".ts",
+			".mjs",
+			".cjs",
+			".js",
+			".mts",
+			".cts"
+		],
+		try: true
+	}) || id;
+}
+export { createNitroEnvironment, createServiceEnvironment, createServiceEnvironments, getEnvRunner, initEnvRunner, nitroServiceProxy };

package/dist/_chunks/nitro.mjs

@@ -1,13 +1,11 @@
-import { i as watchConfig, r as loadConfig } from "../_libs/c12+rc9.mjs";
-import { A as src_default, B as _, F as prettyPath, I as resolveNitroPath, L as writeFile$1, O as scanUnprefixedPublicAssets, R as escapeRegExp, U as v, dt as relative, ft as resolve, it as resolveModuleURL, j as build, k as compressPublicAssets, lt as join, p as runParallel, q as findWorkspaceDir, rt as resolveModulePath } from "../_build/common.mjs";
-import { n as resolveCompatibilityDates, r as resolveCompatibilityDatesFromEnv } from "../_libs/compatx.mjs";
-import { t as klona } from "../_libs/klona.mjs";
-import { n as parse, t as TSConfckCache } from "../_libs/tsconfck.mjs";
-import { n as scanHandlers, t as scanAndSyncOptions } from "./nitro2.mjs";
-import { i as findAllRoutes, n as addRoute, r as createRouter } from "../_libs/rou3.mjs";
-import { n as initNitroRouting } from "./nitro3.mjs";
+import { loadConfig, watchConfig } from "../_libs/c12+rc9.mjs";
+import { _, build, compressPublicAssets, escapeRegExp, findWorkspaceDir, glob, join, prettyPath, relative, resolve, resolveModulePath, resolveModuleURL, resolveNitroPath, runParallel, scanUnprefixedPublicAssets, src_default, v, writeFile as writeFile$1 } from "../_build/common.mjs";
+import { resolveCompatibilityDates, resolveCompatibilityDatesFromEnv } from "../_libs/compatx.mjs";
+import { klona } from "../_libs/klona.mjs";
+import { TSConfckCache, parse } from "../_libs/tsconfck.mjs";
+import { addRoute, compileRouterToString, createRouter, findAllRoutes, findRoute } from "../_libs/rou3.mjs";
 import "../_dev.mjs";
-import { n as z, t as P } from "../_libs/ultrahtml.mjs";
+import { P, z } from "../_libs/ultrahtml.mjs";
 import { createRequire } from "node:module";
 import consola, { consola as consola$1 } from "consola";
 import { Hookable, createDebugger } from "hookable";
@@ -18,6 +16,7 @@ import { pathToFileURL } from "node:url";
 import { defu } from "defu";
 import { joinURL, parseURL, withBase, withLeadingSlash, withQuery, withTrailingSlash, withoutBase, withoutTrailingSlash } from "ufo";
 import { colors } from "consola/utils";
+import { hash } from "ohash";
 import { toRequest } from "h3";
 import http from "node:http";
 const NitroDefaults = {
@@ -474,7 +473,7 @@ function isPkgInstalled(pkg, root) {
 	}
 }
 async function installPkg(pkg, root) {
-	const { addDevDependency } = await import("../_libs/nypm+tinyexec.mjs").then((n) => n.t);
+	const { addDevDependency } = await import("../_libs/nypm+tinyexec.mjs").then((n) => n.dist_exports);
 	return addDevDependency(pkg, { cwd: root });
 }
 function hasNitroViteConfig(options) {
@@ -626,6 +625,234 @@ async function _resolveNitroModule(mod, nitroOptions) {
 		...mod
 	};
 }
+const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+const suffixRegex = /(\.(?<method>connect|delete|get|head|options|patch|post|put|trace))?(\.(?<env>dev|prod|prerender))?$/;
+async function scanAndSyncOptions(nitro) {
+	const scannedPlugins = await scanPlugins(nitro);
+	for (const plugin of scannedPlugins) if (!nitro.options.plugins.includes(plugin)) nitro.options.plugins.push(plugin);
+	if (nitro.options.experimental.tasks) {
+		const scannedTasks = await scanTasks(nitro);
+		for (const scannedTask of scannedTasks) if (scannedTask.name in nitro.options.tasks) {
+			if (!nitro.options.tasks[scannedTask.name].handler) nitro.options.tasks[scannedTask.name].handler = scannedTask.handler;
+		} else nitro.options.tasks[scannedTask.name] = {
+			handler: scannedTask.handler,
+			description: ""
+		};
+	}
+	const scannedModules = await scanModules(nitro);
+	nitro.options.modules = nitro.options.modules || [];
+	for (const modPath of scannedModules) if (!nitro.options.modules.includes(modPath)) nitro.options.modules.push(modPath);
+}
+async function scanHandlers(nitro) {
+	const middleware = await scanMiddleware(nitro);
+	const handlers = await Promise.all([scanServerRoutes(nitro, nitro.options.apiDir || "api", nitro.options.apiBaseURL || "/api"), scanServerRoutes(nitro, nitro.options.routesDir || "routes")]).then((r) => r.flat());
+	const seenHandlers = /* @__PURE__ */ new Set();
+	nitro.scannedHandlers = [...middleware, ...handlers.filter((h) => {
+		const key = `${h.route}\0${h.method}\0${h.env}`;
+		return seenHandlers.has(key) ? false : (seenHandlers.add(key), true);
+	})];
+	nitro.routing.sync();
+	return handlers;
+}
+async function scanMiddleware(nitro) {
+	return (await scanFiles(nitro, "middleware")).map((file) => {
+		return {
+			route: "/**",
+			middleware: true,
+			handler: file.fullPath
+		};
+	});
+}
+async function scanServerRoutes(nitro, dir, prefix = "/") {
+	return (await scanFiles(nitro, dir)).map((file) => {
+		let route = file.path.replace(/\.[A-Za-z]+$/, "").replace(/\(([^(/\\]+)\)[/\\]/g, "").replace(/\[\.{3}]/g, "**").replace(/\[\.{3}([^\]]+)]/g, (_, p) => "**:" + p.replace(/[^\w-]/g, "_")).replace(/\[([^/\]]+)]/g, (_, p) => ":" + p.replace(/[^\w-]/g, "_"));
+		route = withLeadingSlash(withoutTrailingSlash(withBase(route, prefix)));
+		const suffixMatch = route.match(suffixRegex);
+		let method;
+		let env;
+		if (suffixMatch?.index && suffixMatch?.index >= 0) {
+			route = route.slice(0, suffixMatch.index);
+			method = suffixMatch.groups?.method;
+			env = suffixMatch.groups?.env;
+		}
+		route = route.replace(/\/index$/, "") || "/";
+		return {
+			handler: file.fullPath,
+			lazy: true,
+			middleware: false,
+			route,
+			method,
+			env
+		};
+	});
+}
+async function scanPlugins(nitro) {
+	return (await scanFiles(nitro, "plugins")).map((f) => f.fullPath);
+}
+async function scanTasks(nitro) {
+	return (await scanFiles(nitro, "tasks")).map((f) => {
+		return {
+			name: f.path.replace(/\/index$/, "").replace(/\.[A-Za-z]+$/, "").replace(/\//g, ":"),
+			handler: f.fullPath
+		};
+	});
+}
+async function scanModules(nitro) {
+	return (await scanFiles(nitro, "modules")).map((f) => f.fullPath);
+}
+async function scanFiles(nitro, name) {
+	return await Promise.all(nitro.options.scanDirs.map((dir) => scanDir(nitro, dir, name))).then((r) => r.flat());
+}
+async function scanDir(nitro, dir, name) {
+	return (await glob(join(name, GLOB_SCAN_PATTERN), {
+		cwd: dir,
+		dot: true,
+		ignore: nitro.options.ignore,
+		absolute: true
+	}).catch((error) => {
+		if (error?.code === "ENOTDIR") {
+			nitro.logger.warn(`Ignoring \`${join(dir, name)}\`. It must be a directory.`);
+			return [];
+		}
+		throw error;
+	})).map((fullPath) => {
+		return {
+			fullPath,
+			path: relative(join(dir, name), fullPath)
+		};
+	}).sort((a, b) => a.path.localeCompare(b.path));
+}
+const isGlobalMiddleware = (h) => !h.method && (!h.route || h.route === "/**");
+function initNitroRouting(nitro) {
+	const envConditions = new Set([
+		nitro.options.dev ? "dev" : "prod",
+		nitro.options.preset,
+		nitro.options.preset === "nitro-prerender" ? "prerender" : void 0
+	].filter(Boolean));
+	const matchesEnv = (h) => {
+		const envs = (Array.isArray(h.env) ? h.env : [h.env]).filter(Boolean);
+		return envs.length === 0 || envs.some((env) => envConditions.has(env));
+	};
+	const routes = new Router(nitro.options.baseURL);
+	const routeRules = new Router(nitro.options.baseURL);
+	const globalMiddleware = [];
+	const routedMiddleware = new Router(nitro.options.baseURL);
+	const sync = () => {
+		routeRules._update(Object.entries(nitro.options.routeRules).map(([route, data]) => ({
+			route,
+			method: "",
+			data: {
+				...data,
+				_route: route
+			}
+		})));
+		const _routes = [
+			...Object.entries(nitro.options.routes).flatMap(([route, handler]) => {
+				if (typeof handler === "string") handler = { handler };
+				return {
+					...handler,
+					route,
+					middleware: false
+				};
+			}),
+			...nitro.options.handlers,
+			...nitro.scannedHandlers
+		].filter((h) => h && !h.middleware && matchesEnv(h));
+		if (nitro.options.serverEntry && nitro.options.serverEntry.handler) _routes.push({
+			route: "/**",
+			lazy: false,
+			format: nitro.options.serverEntry.format,
+			handler: nitro.options.serverEntry.handler
+		});
+		if (nitro.options.renderer?.handler) _routes.push({
+			route: "/**",
+			lazy: true,
+			handler: nitro.options.renderer?.handler
+		});
+		routes._update(_routes.map((h) => ({
+			...h,
+			method: h.method || "",
+			data: handlerWithImportHash(h)
+		})), { merge: true });
+		const _middleware = [...nitro.scannedHandlers, ...nitro.options.handlers].filter((h) => h && h.middleware && matchesEnv(h));
+		if (nitro.options.serveStatic) _middleware.unshift({
+			route: "/**",
+			middleware: true,
+			handler: join(runtimeDir, "internal/static")
+		});
+		globalMiddleware.splice(0, globalMiddleware.length, ..._middleware.filter((h) => isGlobalMiddleware(h)).map((m) => handlerWithImportHash(m)));
+		routedMiddleware._update(_middleware.filter((h) => !isGlobalMiddleware(h)).map((h) => ({
+			...h,
+			method: h.method || "",
+			data: handlerWithImportHash(h)
+		})));
+	};
+	nitro.routing = Object.freeze({
+		sync,
+		routes,
+		routeRules,
+		globalMiddleware,
+		routedMiddleware
+	});
+}
+function handlerWithImportHash(h) {
+	const id = (h.lazy ? "_lazy_" : "_") + hash(h.handler).replace(/-/g, "").slice(0, 6);
+	return {
+		...h,
+		_importHash: id
+	};
+}
+var Router = class {
+	_routes;
+	_router;
+	_compiled;
+	_baseURL;
+	constructor(baseURL) {
+		this._update([]);
+		this._baseURL = baseURL || "";
+		if (this._baseURL.endsWith("/")) this._baseURL = this._baseURL.slice(0, -1);
+	}
+	get routes() {
+		return this._routes;
+	}
+	_update(routes, opts) {
+		this._routes = routes;
+		this._router = createRouter();
+		this._compiled = void 0;
+		for (const route of routes) addRoute(this._router, route.method, this._baseURL + route.route, route.data);
+		if (opts?.merge) mergeCatchAll(this._router);
+	}
+	hasRoutes() {
+		return this._routes.length > 0;
+	}
+	compileToString(opts) {
+		const key = opts ? hash(opts) : "";
+		this._compiled ||= {};
+		if (this._compiled[key]) return this._compiled[key];
+		this._compiled[key] = compileRouterToString(this._router, void 0, opts);
+		if (this.routes.length === 1 && this.routes[0].route === "/**" && this.routes[0].method === "") {
+			const data = (opts?.serialize || JSON.stringify)(this.routes[0].data);
+			let retCode = `{data,params:{"_":p.slice(1)}}`;
+			if (opts?.matchAll) retCode = `[${retCode}]`;
+			this._compiled[key] = `/* @__PURE__ */ (() => {const data=${data};return ((_m, p)=>{return ${retCode};})})()`;
+		}
+		return this._compiled[key];
+	}
+	match(method, path) {
+		return findRoute(this._router, method, path)?.data;
+	}
+	matchAll(method, path) {
+		return findAllRoutes(this._router, method, path).map((route) => route.data);
+	}
+};
+function mergeCatchAll(router) {
+	const handlers = router.root?.wildcard?.methods?.[""];
+	if (!handlers || handlers.length < 2) return;
+	handlers.splice(0, handlers.length, {
+		...handlers[0],
+		data: handlers.map((h) => h.data)
+	});
+}
 const nitroInstances = globalThis.__nitro_instances__ ||= [];
 const globalKey = "__nitro_builder__";
 function registerNitroInstance(nitro) {
@@ -675,7 +902,7 @@ async function createNitro(config = {}, opts = {}) {
 	nitro.hooks.addHooks(nitro.options.hooks);
 	await installModules(nitro);
 	if (nitro.options.imports) {
-		const { createUnimport } = await import("../_build/common.mjs").then((n) => n.v);
+		const { createUnimport } = await import("../_build/common.mjs").then((n) => n.dist_exports);
 		nitro.unimport = createUnimport(nitro.options.imports);
 		await nitro.unimport.init();
 		nitro.options.virtual["#imports"] = () => nitro.unimport?.toExports() || "";
@@ -963,4 +1190,4 @@ function _pidIsRunning(pid) {
 		return false;
 	}
 }
-export { loadOptions as a, createNitro as i, runTask as n, prerender as r, listTasks as t };
+export { Router, createNitro, listTasks, loadOptions, prerender, runTask, scanHandlers };

package/dist/_chunks/nitro2.mjs

@@ -1,100 +1,127 @@
-import { M as glob, dt as relative, lt as join } from "../_build/common.mjs";
-import { withBase, withLeadingSlash, withoutTrailingSlash } from "ufo";
-const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
-const suffixRegex = /(\.(?<method>connect|delete|get|head|options|patch|post|put|trace))?(\.(?<env>dev|prod|prerender))?$/;
-async function scanAndSyncOptions(nitro) {
-	const scannedPlugins = await scanPlugins(nitro);
-	for (const plugin of scannedPlugins) if (!nitro.options.plugins.includes(plugin)) nitro.options.plugins.push(plugin);
-	if (nitro.options.experimental.tasks) {
-		const scannedTasks = await scanTasks(nitro);
-		for (const scannedTask of scannedTasks) if (scannedTask.name in nitro.options.tasks) {
-			if (!nitro.options.tasks[scannedTask.name].handler) nitro.options.tasks[scannedTask.name].handler = scannedTask.handler;
-		} else nitro.options.tasks[scannedTask.name] = {
-			handler: scannedTask.handler,
-			description: ""
+import { getBuildInfo, join, prettyPath, resolve } from "../_build/common.mjs";
+import { proxyFetch, proxyUpgrade } from "../_libs/httpxy.mjs";
+import consola from "consola";
+import { spawn } from "node:child_process";
+async function startPreview(opts) {
+	const { outputDir, buildInfo } = await getBuildInfo(opts.rootDir);
+	if (!buildInfo) throw new Error("Cannot load nitro build info. Make sure to build first.");
+	const info = [
+		["Build Directory:", prettyPath(outputDir)],
+		["Date:", buildInfo.date && new Date(buildInfo.date).toLocaleString()],
+		["Nitro Version:", buildInfo.versions.nitro],
+		["Nitro Preset:", buildInfo.preset],
+		buildInfo.framework?.name !== "nitro" && ["Framework:", buildInfo.framework?.name + (buildInfo.framework?.version ? ` (v${buildInfo.framework.version})` : "")]
+	].filter((i) => i && i[1]);
+	consola.box({
+		title: " [Build Info] ",
+		message: info.map((i) => `- ${i[0]} ${i[1]}`).join("\n")
+	});
+	const dotEnvEntries = await loadPreviewDotEnv(opts.rootDir);
+	if (dotEnvEntries.length > 0) consola.box({
+		title: " [Environment Variables] ",
+		message: [
+			"Loaded variables from .env files (preview mode only).",
+			"Set platform environment variables for production:",
+			...dotEnvEntries.map(([key, val]) => ` - ${key}`)
+		].join("\n")
+	});
+	if (buildInfo.preset.includes("cloudflare")) {
+		if (!buildInfo.commands?.preview) throw new Error(`No nitro build preview command found for the "${buildInfo.preset}" preset.`);
+		return await runPreviewCommand({
+			command: buildInfo.commands.preview,
+			rootDir: opts.rootDir,
+			env: dotEnvEntries
+		});
+	}
+	let fetchHandler = () => Promise.resolve(new Response("Not Found", { status: 404 }));
+	if (buildInfo.serverEntry) {
+		for (const [key, val] of dotEnvEntries) if (!process.env[key]) process.env[key] = val;
+		const { loadServerEntry } = await import("srvx/loader");
+		const entry = await loadServerEntry({
+			entry: resolve(outputDir, buildInfo.serverEntry),
+			...opts.loader
+		});
+		if (entry.fetch) fetchHandler = entry.fetch;
+	}
+	if (buildInfo.publicDir) {
+		const { serveStatic } = await import("srvx/static");
+		const staticHandler = serveStatic({ dir: join(outputDir, buildInfo.publicDir) });
+		const originalFetchHandler = fetchHandler;
+		fetchHandler = async (req) => {
+			const staticRes = await staticHandler(req, () => void 0);
+			if (staticRes) return staticRes;
+			return originalFetchHandler(req);
 		};
 	}
-	const scannedModules = await scanModules(nitro);
-	nitro.options.modules = nitro.options.modules || [];
-	for (const modPath of scannedModules) if (!nitro.options.modules.includes(modPath)) nitro.options.modules.push(modPath);
+	return {
+		fetch: fetchHandler,
+		async close() {}
+	};
 }
-async function scanHandlers(nitro) {
-	const middleware = await scanMiddleware(nitro);
-	const handlers = await Promise.all([scanServerRoutes(nitro, nitro.options.apiDir || "api", nitro.options.apiBaseURL || "/api"), scanServerRoutes(nitro, nitro.options.routesDir || "routes")]).then((r) => r.flat());
-	const seenHandlers = /* @__PURE__ */ new Set();
-	nitro.scannedHandlers = [...middleware, ...handlers.filter((h) => {
-		const key = `${h.route}\0${h.method}\0${h.env}`;
-		return seenHandlers.has(key) ? false : (seenHandlers.add(key), true);
-	})];
-	nitro.routing.sync();
-	return handlers;
-}
-async function scanMiddleware(nitro) {
-	return (await scanFiles(nitro, "middleware")).map((file) => {
-		return {
-			route: "/**",
-			middleware: true,
-			handler: file.fullPath
-		};
+async function loadPreviewDotEnv(root) {
+	const { loadDotenv } = await import("../_libs/c12+rc9.mjs").then((n) => n.dist_exports);
+	const env = await loadDotenv({
+		cwd: root,
+		fileName: [
+			".env.preview",
+			".env.production",
+			".env"
+		]
 	});
+	return Object.entries(env).filter(([_key, val]) => val);
 }
-async function scanServerRoutes(nitro, dir, prefix = "/") {
-	return (await scanFiles(nitro, dir)).map((file) => {
-		let route = file.path.replace(/\.[A-Za-z]+$/, "").replace(/\(([^(/\\]+)\)[/\\]/g, "").replace(/\[\.{3}]/g, "**").replace(/\[\.{3}([^\]]+)]/g, (_, p) => "**:" + p.replace(/[^\w-]/g, "_")).replace(/\[([^/\]]+)]/g, (_, p) => ":" + p.replace(/[^\w-]/g, "_"));
-		route = withLeadingSlash(withoutTrailingSlash(withBase(route, prefix)));
-		const suffixMatch = route.match(suffixRegex);
-		let method;
-		let env;
-		if (suffixMatch?.index && suffixMatch?.index >= 0) {
-			route = route.slice(0, suffixMatch.index);
-			method = suffixMatch.groups?.method;
-			env = suffixMatch.groups?.env;
+async function runPreviewCommand(opts) {
+	const [arg0, ...args] = opts.command.split(" ");
+	consola.info(`Spawning preview server...`);
+	consola.info(opts.command);
+	console.log("");
+	const { getRandomPort, waitForPort } = await import("get-port-please");
+	const randomPort = await getRandomPort();
+	const child = spawn(arg0, [
+		...args,
+		"--port",
+		String(randomPort),
+		"--host",
+		"localhost"
+	], {
+		stdio: "inherit",
+		cwd: opts.rootDir,
+		env: {
+			...process.env,
+			...Object.fromEntries(opts.env ?? []),
+			PORT: String(randomPort)
 		}
-		route = route.replace(/\/index$/, "") || "/";
-		return {
-			handler: file.fullPath,
-			lazy: true,
-			middleware: false,
-			route,
-			method,
-			env
-		};
 	});
-}
-async function scanPlugins(nitro) {
-	return (await scanFiles(nitro, "plugins")).map((f) => f.fullPath);
-}
-async function scanTasks(nitro) {
-	return (await scanFiles(nitro, "tasks")).map((f) => {
-		return {
-			name: f.path.replace(/\/index$/, "").replace(/\.[A-Za-z]+$/, "").replace(/\//g, ":"),
-			handler: f.fullPath
-		};
+	const killChild = (signal) => {
+		if (child && !child.killed) child.kill(signal);
+	};
+	for (const sig of ["SIGINT", "SIGHUP"]) process.once(sig, () => {
+		killChild(sig);
 	});
-}
-async function scanModules(nitro) {
-	return (await scanFiles(nitro, "modules")).map((f) => f.fullPath);
-}
-async function scanFiles(nitro, name) {
-	return await Promise.all(nitro.options.scanDirs.map((dir) => scanDir(nitro, dir, name))).then((r) => r.flat());
-}
-async function scanDir(nitro, dir, name) {
-	return (await glob(join(name, GLOB_SCAN_PATTERN), {
-		cwd: dir,
-		dot: true,
-		ignore: nitro.options.ignore,
-		absolute: true
-	}).catch((error) => {
-		if (error?.code === "ENOTDIR") {
-			nitro.logger.warn(`Ignoring \`${join(dir, name)}\`. It must be a directory.`);
-			return [];
+	child.once("exit", (code) => {
+		if (code && code !== 0) consola.error(`[nitro] Preview server exited with code ${code}`);
+	});
+	await waitForPort(randomPort, {
+		retries: 20,
+		delay: 500,
+		host: "localhost"
+	});
+	return {
+		fetch(req) {
+			return proxyFetch({
+				port: randomPort,
+				host: "localhost"
+			}, req);
+		},
+		async upgrade(req, socket, head, opts) {
+			await proxyUpgrade({
+				port: randomPort,
+				host: "localhost"
+			}, req, socket, head, opts);
+		},
+		async close() {
+			killChild("SIGTERM");
 		}
-		throw error;
-	})).map((fullPath) => {
-		return {
-			fullPath,
-			path: relative(join(dir, name), fullPath)
-		};
-	}).sort((a, b) => a.path.localeCompare(b.path));
+	};
 }
-export { scanHandlers as n, scanAndSyncOptions as t };
+export { startPreview };