nitro-nightly 3.0.1-20260106-130706-e20c92d9 → 3.0.1-20260106-202835-5325b208

package/dist/vite.mjs

@@ -1,21 +1,1826 @@
-import "./_rolldown.mjs";
-import "./_libs/c12.mjs";
-import "./_nitro.mjs";
+import { i as __toESM } from "./_rolldown.mjs";
+import { a as isAbsolute$1, l as relative$1, n as basename$1, o as join$1, r as dirname$1, s as normalize$1, u as resolve$1 } from "./_libs/pathe.mjs";
+import "./_libs/dotenv.mjs";
+import { t as resolveModulePath } from "./_libs/exsolve.mjs";
+import { t as debounce } from "./_libs/perfect-debounce.mjs";
+import { t as formatCompatibilityDate } from "./_libs/compatx.mjs";
+import { i as a, r as T, t as A } from "./_libs/std-env.mjs";
+import { a as copyPublicAssets, i as prepare, s as createNitro } from "./_nitro.mjs";
 import "./_libs/tsconfck.mjs";
-import "./_build/shared2.mjs";
-import "./_libs/@rollup/plugin-commonjs.mjs";
-import "./_nitro2.mjs";
-import "./_libs/mime.mjs";
+import { n as prettyPath } from "./_build/shared2.mjs";
+import "./_libs/fdir.mjs";
+import { t as glob } from "./_libs/tinyglobby.mjs";
+import { i as scanHandlers } from "./_nitro2.mjs";
+import { t as src_default } from "./_libs/mime.mjs";
 import "./_libs/acorn.mjs";
-import "./_libs/@hiogawa/vite-plugin-fullstack.mjs";
-import "./_libs/unimport.mjs";
-import "./_build/shared3.mjs";
-import "./_dev.mjs";
-import "./_libs/@rollup/plugin-alias.mjs";
-import "./_libs/@rollup/plugin-inject.mjs";
-import "./_build/shared4.mjs";
-import "./_libs/etag.mjs";
-import "./_libs/@rollup/plugin-replace.mjs";
-import { t as nitro } from "./_build/vite.plugin.mjs";
-
-export { nitro };
+import { i as genSafeVariableName, t as genImport } from "./_libs/knitwork.mjs";
+import "./_libs/@jridgewell/sourcemap-codec.mjs";
+import "./_libs/js-tokens.mjs";
+import { n as writeBuildInfo, t as getBuildInfo } from "./_build/shared3.mjs";
+import { i as NodeEnvRunner, r as NitroDevApp } from "./_dev.mjs";
+import { a as watch$1 } from "./_libs/chokidar.mjs";
+import { t as alias } from "./_libs/@rollup/plugin-alias.mjs";
+import "./_libs/@rollup/pluginutils.mjs";
+import { t as inject } from "./_libs/@rollup/plugin-inject.mjs";
+import { t as require_etag } from "./_libs/etag.mjs";
+import { t as replace } from "./_libs/@rollup/plugin-replace.mjs";
+import { t as unwasm } from "./_libs/unwasm.mjs";
+import { r as assetsPlugin } from "./_libs/@hiogawa/vite-plugin-fullstack.mjs";
+import { builtinModules, createRequire } from "node:module";
+import consola$1 from "consola";
+import { existsSync, promises, watch } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { join, resolve } from "node:path";
+import { defu } from "defu";
+import { joinURL, withTrailingSlash } from "ufo";
+import { pkgDir, presetsDir, runtimeDependencies, runtimeDir } from "nitro/meta";
+import { colors } from "consola/utils";
+import { hash } from "ohash";
+import { camelCase } from "scule";
+import { NodeRequest, sendNodeResponse } from "srvx/node";
+import { defineEnv } from "unenv";
+import { connectors } from "db0";
+import { RENDER_CONTEXT_KEYS, compileTemplateToString, hasTemplateSyntax } from "rendu";
+import { builtinDrivers, normalizeKey } from "unstorage";
+import { transformSync } from "oxc-transform";
+import { NodeNativePackages } from "nf3";
+import { DevEnvironment } from "vite";
+import { spawn } from "node:child_process";
+
+//#region src/utils/regex.ts
+function escapeRegExp(string) {
+	return string.replace(/[-\\^$*+?.()|[\]{}]/g, String.raw`\$&`);
+}
+function pathRegExp(string) {
+	if (A) string = string.replace(/\\/g, "/");
+	let escaped = escapeRegExp(string);
+	if (A) escaped = escaped.replace(/\//g, String.raw`[/\\]`);
+	return escaped;
+}
+function toPathRegExp(input) {
+	if (input instanceof RegExp) return input;
+	if (typeof input === "string") return new RegExp(pathRegExp(input));
+	throw new TypeError("Expected a string or RegExp", { cause: input });
+}
+
+//#endregion
+//#region src/build/config.ts
+function baseBuildConfig(nitro$1) {
+	const extensions = [
+		".ts",
+		".mjs",
+		".js",
+		".json",
+		".node",
+		".tsx",
+		".jsx"
+	];
+	const isNodeless = nitro$1.options.node === false;
+	const importMetaInjections = {
+		dev: nitro$1.options.dev,
+		preset: nitro$1.options.preset,
+		prerender: nitro$1.options.preset === "nitro-prerender",
+		nitro: true,
+		server: true,
+		client: false,
+		baseURL: nitro$1.options.baseURL,
+		_asyncContext: nitro$1.options.experimental.asyncContext,
+		_tasks: nitro$1.options.experimental.tasks
+	};
+	const replacements = {
+		...Object.fromEntries(Object.entries(importMetaInjections).map(([key, val]) => [`import.meta.${key}`, JSON.stringify(val)])),
+		...nitro$1.options.replace
+	};
+	const { env } = defineEnv({
+		nodeCompat: isNodeless,
+		resolve: true,
+		presets: nitro$1.options.unenv,
+		overrides: { alias: nitro$1.options.alias }
+	});
+	return {
+		extensions,
+		isNodeless,
+		replacements,
+		env,
+		aliases: resolveAliases({ ...env.alias }),
+		noExternal: getNoExternals(nitro$1),
+		ignoreWarningCodes: new Set([
+			"EVAL",
+			"CIRCULAR_DEPENDENCY",
+			"THIS_IS_UNDEFINED",
+			"EMPTY_BUNDLE"
+		])
+	};
+}
+function getNoExternals(nitro$1) {
+	const noExternal = [
+		/\.[mc]?tsx?$/,
+		/^(?:[\0#~.]|virtual:)/,
+		/* @__PURE__ */ new RegExp("^" + pathRegExp(pkgDir) + "(?!.*node_modules)"),
+		...[nitro$1.options.rootDir, ...nitro$1.options.scanDirs.filter((dir) => dir.includes("node_modules") || !dir.startsWith(nitro$1.options.rootDir))].map((dir) => /* @__PURE__ */ new RegExp("^" + pathRegExp(dir) + "(?!.*node_modules)"))
+	];
+	if (nitro$1.options.wasm !== false) noExternal.push(/\.wasm$/);
+	if (Array.isArray(nitro$1.options.noExternals)) noExternal.push(...nitro$1.options.noExternals.filter(Boolean).map((item) => toPathRegExp(item)));
+	return noExternal.sort((a$1, b) => a$1.source.length - b.source.length);
+}
+function resolveAliases(_aliases) {
+	const aliases = Object.fromEntries(Object.entries(_aliases).sort(([a$1], [b]) => b.split("/").length - a$1.split("/").length || b.length - a$1.length));
+	for (const key in aliases) for (const alias$1 in aliases) {
+		if (![
+			"~",
+			"@",
+			"#"
+		].includes(alias$1[0])) continue;
+		if (alias$1 === "@" && !aliases[key].startsWith("@/")) continue;
+		if (aliases[key].startsWith(alias$1)) aliases[key] = aliases[alias$1] + aliases[key].slice(alias$1.length);
+	}
+	return aliases;
+}
+
+//#endregion
+//#region src/build/chunks.ts
+const virtualRe = /^(?:\0|#|virtual:)/;
+const NODE_MODULES_RE$1 = /node_modules[/\\][^.]/;
+function libChunkName(id) {
+	return `_libs/${id.match(/.*(?:[/\\])node_modules(?:[/\\])(?<package>@[^/\\]+[/\\][^/\\]+|[^/\\.][^/\\]*)/)?.groups?.package || "common"}`;
+}
+function getChunkName(chunk, nitro$1) {
+	if (chunk.name.startsWith("_libs/")) return `${chunk.name}.mjs`;
+	if (chunk.name === "rolldown-runtime") return "_rolldown.mjs";
+	if (chunk.moduleIds.length === 0) return `_chunks/${chunk.name}.mjs`;
+	const ids = chunk.moduleIds.filter((id) => !virtualRe.test(id));
+	if (ids.length === 0) {
+		if (chunk.moduleIds.every((id) => id.includes("virtual:raw"))) return `_raw/[name].mjs`;
+		return `_virtual/[name].mjs`;
+	}
+	if (ids.every((id) => id.endsWith(".wasm"))) return `_wasm/[name].mjs`;
+	if (ids.every((id) => id.includes("vite/services"))) return `_ssr/[name].mjs`;
+	if (ids.every((id) => id.startsWith(nitro$1.options.buildDir))) return `_build/[name].mjs`;
+	if (ids.every((id) => id.startsWith(runtimeDir) || id.startsWith(presetsDir))) return `_nitro/[name].mjs`;
+	const mainId = ids.at(-1);
+	if (mainId) {
+		const routeHandler = nitro$1.routing.routes.routes.flatMap((h) => h.data).find((h) => h.handler === mainId);
+		if (routeHandler?.route) return `_routes/${routeToFsPath(routeHandler.route)}.mjs`;
+		if (Object.entries(nitro$1.options.tasks).find(([_, task]) => task.handler === mainId)) return `_tasks/[name].mjs`;
+	}
+	return `_chunks/[name].mjs`;
+}
+function routeToFsPath(route) {
+	return route.split("/").slice(1).map((s) => `${s.replace(/[:*]+/g, "$").replace(/[^$a-zA-Z0-9_.[\]/]/g, "_")}`).join("/") || "index";
+}
+
+//#endregion
+//#region src/build/virtual/database.ts
+function database(nitro$1) {
+	return {
+		id: "#nitro/virtual/database",
+		template: () => {
+			if (!nitro$1.options.experimental.database) return `export const connectionConfigs = {};`;
+			const dbConfigs = nitro$1.options.dev && nitro$1.options.devDatabase || nitro$1.options.database;
+			const connectorsNames = [...new Set(Object.values(dbConfigs || {}).map((config) => config?.connector))].filter(Boolean);
+			for (const name of connectorsNames) if (!connectors[name]) throw new Error(`Database connector "${name}" is invalid.`);
+			return `
+${connectorsNames.map((name) => `import ${camelCase(name)}Connector from "${connectors[name]}";`).join("\n")}
+
+export const connectionConfigs = {
+  ${Object.entries(dbConfigs || {}).filter(([, config]) => !!config?.connector).map(([name, { connector, options }]) => `${name}: {
+          connector: ${camelCase(connector)}Connector,
+          options: ${JSON.stringify(options)}
+        }`).join(",\n")}
+};
+        `;
+		}
+	};
+}
+
+//#endregion
+//#region src/build/virtual/error-handler.ts
+function errorHandler(nitro$1) {
+	return {
+		id: "#nitro/virtual/error-handler",
+		template: () => {
+			const errorHandlers = Array.isArray(nitro$1.options.errorHandler) ? nitro$1.options.errorHandler : [nitro$1.options.errorHandler];
+			const builtinHandler = join$1(runtimeDir, `internal/error/${nitro$1.options.dev ? "dev" : "prod"}`);
+			return `
+${errorHandlers.map((h, i) => `import errorHandler$${i} from "${h}";`).join("\n")}
+
+const errorHandlers = [${errorHandlers.map((_, i) => `errorHandler$${i}`).join(", ")}];
+
+import { defaultHandler } from "${builtinHandler}";
+
+export default async function(error, event) {
+  for (const handler of errorHandlers) {
+    try {
+      const response = await handler(error, event, { defaultHandler });
+      if (response) {
+        return response;
+      }
+    } catch(error) {
+      // Handler itself thrown, log and continue
+      console.error(error);
+    }
+  }
+  // H3 will handle fallback
+}
+`;
+		}
+	};
+}
+
+//#endregion
+//#region src/build/virtual/feature-flags.ts
+function featureFlags(nitro$1) {
+	return {
+		id: "#nitro/virtual/feature-flags",
+		template: () => {
+			const featureFlags$1 = {
+				hasRoutes: nitro$1.routing.routes.hasRoutes(),
+				hasRouteRules: nitro$1.routing.routeRules.hasRoutes(),
+				hasRoutedMiddleware: nitro$1.routing.routedMiddleware.hasRoutes(),
+				hasGlobalMiddleware: nitro$1.routing.globalMiddleware.length > 0,
+				hasPlugins: nitro$1.options.plugins.length > 0,
+				hasHooks: nitro$1.options.features?.runtimeHooks ?? nitro$1.options.plugins.length > 0,
+				hasWebSocket: nitro$1.options.features?.websocket ?? nitro$1.options.experimental.websocket ?? false
+			};
+			return Object.entries(featureFlags$1).map(([key, value]) => `export const ${key} = ${Boolean(value)};`).join("\n");
+		}
+	};
+}
+
+//#endregion
+//#region src/build/virtual/plugins.ts
+function plugins(nitro$1) {
+	return {
+		id: "#nitro/virtual/plugins",
+		template: () => {
+			const nitroPlugins = [...new Set(nitro$1.options.plugins)];
+			return `
+  ${nitroPlugins.map((plugin) => `import _${hash(plugin).replace(/-/g, "")} from "${plugin}";`).join("\n")}
+
+  export const plugins = [
+    ${nitroPlugins.map((plugin) => `_${hash(plugin).replace(/-/g, "")}`).join(",\n")}
+  ]
+      `;
+		}
+	};
+}
+
+//#endregion
+//#region src/build/virtual/polyfills.ts
+function polyfills(_nitro, polyfills$1) {
+	return {
+		id: "#nitro/virtual/polyfills",
+		moduleSideEffects: true,
+		template: () => {
+			return polyfills$1.map((p) => `import '${p}';`).join("\n") || `/* No polyfills */`;
+		}
+	};
+}
+
+//#endregion
+//#region src/build/virtual/public-assets.ts
+var import_etag = /* @__PURE__ */ __toESM(require_etag(), 1);
+const readAssetHandler = {
+	true: "node",
+	node: "node",
+	false: "null",
+	deno: "deno",
+	inline: "inline"
+};
+function publicAssets(nitro$1) {
+	return [
+		{
+			id: "#nitro/virtual/public-assets-data",
+			template: async () => {
+				const assets = {};
+				const files = await glob("**", {
+					cwd: nitro$1.options.output.publicDir,
+					absolute: false,
+					dot: true
+				});
+				for (const id of files) {
+					let mimeType = src_default.getType(id.replace(/\.(gz|br)$/, "")) || "text/plain";
+					if (mimeType.startsWith("text")) mimeType += "; charset=utf-8";
+					const fullPath = resolve$1(nitro$1.options.output.publicDir, id);
+					const assetData = await promises.readFile(fullPath);
+					const etag = (0, import_etag.default)(assetData);
+					const stat$2 = await promises.stat(fullPath);
+					const assetId = joinURL(nitro$1.options.baseURL, decodeURIComponent(id));
+					let encoding;
+					if (id.endsWith(".gz")) encoding = "gzip";
+					else if (id.endsWith(".br")) encoding = "br";
+					assets[assetId] = {
+						type: nitro$1._prerenderMeta?.[assetId]?.contentType || mimeType,
+						encoding,
+						etag,
+						mtime: stat$2.mtime.toJSON(),
+						size: stat$2.size,
+						path: relative$1(nitro$1.options.output.serverDir, fullPath),
+						data: nitro$1.options.serveStatic === "inline" ? assetData.toString("base64") : void 0
+					};
+				}
+				return `export default ${JSON.stringify(assets, null, 2)};`;
+			}
+		},
+		{
+			id: "#nitro/virtual/public-assets",
+			template: () => {
+				const publicAssetBases = Object.fromEntries(nitro$1.options.publicAssets.filter((dir) => !dir.fallthrough && dir.baseURL !== "/").map((dir) => [withTrailingSlash(joinURL(nitro$1.options.baseURL, dir.baseURL || "/")), { maxAge: dir.maxAge }]));
+				return `
+import assets from '#nitro/virtual/public-assets-data'
+export { readAsset } from "${`#nitro/virtual/public-assets-${readAssetHandler[nitro$1.options.serveStatic] || "null"}`}"
+export const publicAssetBases = ${JSON.stringify(publicAssetBases)}
+
+export function isPublicAssetURL(id = '') {
+  if (assets[id]) {
+    return true
+  }
+  for (const base in publicAssetBases) {
+    if (id.startsWith(base)) { return true }
+  }
+  return false
+}
+
+export function getPublicAssetMeta(id = '') {
+  for (const base in publicAssetBases) {
+    if (id.startsWith(base)) { return publicAssetBases[base] }
+  }
+  return {}
+}
+
+export function getAsset (id) {
+  return assets[id]
+}
+`;
+			}
+		},
+		{
+			id: "#nitro/virtual/public-assets-node",
+			template: () => {
+				return `
+import { promises as fsp } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { resolve, dirname } from 'node:path'
+import assets from '#nitro/virtual/public-assets-data'
+export function readAsset (id) {
+  const serverDir = dirname(fileURLToPath(globalThis.__nitro_main__))
+  return fsp.readFile(resolve(serverDir, assets[id].path))
+}`;
+			}
+		},
+		{
+			id: "#nitro/virtual/public-assets-deno",
+			template: () => {
+				return `
+import assets from '#nitro/virtual/public-assets-data'
+export function readAsset (id) {
+  // https://deno.com/deploy/docs/serve-static-assets
+  const path = '.' + decodeURIComponent(new URL(\`../public\${id}\`, 'file://').pathname)
+  return Deno.readFile(path);
+}`;
+			}
+		},
+		{
+			id: "#nitro/virtual/public-assets-null",
+			template: () => {
+				return `
+    export function readAsset (id) {
+        return Promise.resolve(null);
+    }`;
+			}
+		},
+		{
+			id: "#nitro/virtual/public-assets-inline",
+			template: () => {
+				return `
+  import assets from '#nitro/virtual/public-assets-data'
+  export function readAsset (id) {
+    if (!assets[id]) { return undefined }
+    if (assets[id]._data) { return assets[id]._data }
+    if (!assets[id].data) { return assets[id].data }
+    assets[id]._data = Uint8Array.from(atob(assets[id].data), (c) => c.charCodeAt(0))
+    return assets[id]._data
+}`;
+			}
+		}
+	];
+}
+
+//#endregion
+//#region src/build/virtual/renderer-template.ts
+function rendererTemplate(nitro$1) {
+	return {
+		id: "#nitro/virtual/renderer-template",
+		template: async () => {
+			const template = nitro$1.options.renderer?.template;
+			if (typeof template !== "string") return `
+            export const rendererTemplate = () => '<!-- renderer.template is not set -->';
+            export const rendererTemplateFile = undefined;
+            export const isStaticTemplate = true;`;
+			if (nitro$1.options.dev) return `
+            import { readFile } from 'node:fs/promises';
+            export const rendererTemplate = () => readFile(${JSON.stringify(template)}, "utf8");
+            export const rendererTemplateFile = ${JSON.stringify(template)};
+            export const isStaticTemplate = ${JSON.stringify(nitro$1.options.renderer?.static)};
+            `;
+			else {
+				const html = await readFile(template, "utf8");
+				if (nitro$1.options.renderer?.static ?? !hasTemplateSyntax(html)) return `
+              import { HTTPResponse } from "h3";
+              export const rendererTemplate = () => new HTTPResponse(${JSON.stringify(html)}, { headers: { "content-type": "text/html; charset=utf-8" } });
+            `;
+				else return `
+            import { renderToResponse } from 'rendu'
+            import { serverFetch } from 'nitro/app'
+            const template = ${compileTemplateToString(html, { contextKeys: [...RENDER_CONTEXT_KEYS] })};
+            export const rendererTemplate = (request) => renderToResponse(template, { request, context: { serverFetch } })
+            `;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/build/virtual/routing-meta.ts
+function routingMeta(nitro$1) {
+	return {
+		id: "#nitro/virtual/routing-meta",
+		template: () => {
+			const routeHandlers = uniqueBy$1(Object.values(nitro$1.routing.routes.routes).flatMap((h) => h.data), "_importHash");
+			return `
+  ${routeHandlers.map((h) => `import ${h._importHash}Meta from "${h.handler}?meta";`).join("\n")}
+export const handlersMeta = [
+  ${routeHandlers.map((h) => `{ route: ${JSON.stringify(h.route)}, method: ${JSON.stringify(h.method?.toLowerCase())}, meta: ${h._importHash}Meta }`).join(",\n")}
+  ];
+        `.trim();
+		}
+	};
+}
+function uniqueBy$1(arr, key) {
+	return [...new Map(arr.map((item) => [item[key], item])).values()];
+}
+
+//#endregion
+//#region src/build/virtual/routing.ts
+const RuntimeRouteRules = [
+	"headers",
+	"redirect",
+	"proxy",
+	"cache"
+];
+function routing(nitro$1) {
+	return {
+		id: "#nitro/virtual/routing",
+		template: () => {
+			const allHandlers = uniqueBy([
+				...Object.values(nitro$1.routing.routes.routes).flatMap((h) => h.data),
+				...Object.values(nitro$1.routing.routedMiddleware.routes).map((h) => h.data),
+				...nitro$1.routing.globalMiddleware
+			], "_importHash");
+			return `
+import * as __routeRules__ from "#nitro/runtime/route-rules";
+import * as srvxNode from "srvx/node"
+import * as h3 from "h3";
+
+export const findRouteRules = ${nitro$1.routing.routeRules.compileToString({
+				serialize: serializeRouteRule,
+				matchAll: true
+			})}
+
+const multiHandler = (...handlers) => {
+  const final = handlers.pop()
+  const middleware = handlers.filter(Boolean).map(h => h3.toMiddleware(h));
+  return (ev) => h3.callMiddleware(ev, middleware, final);
+}
+
+${allHandlers.filter((h) => !h.lazy).map((h) => `import ${h._importHash} from "${h.handler}";`).join("\n")}
+
+${allHandlers.filter((h) => h.lazy).map((h) => `const ${h._importHash} = h3.defineLazyEventHandler(() => import("${h.handler}")${h.format === "node" ? ".then(m => srvxNode.toFetchHandler(m.default))" : ""});`).join("\n")}
+
+export const findRoute = ${nitro$1.routing.routes.compileToString({ serialize: serializeHandler })}
+
+export const findRoutedMiddleware = ${nitro$1.routing.routedMiddleware.compileToString({
+				serialize: serializeHandler,
+				matchAll: true
+			})};
+
+export const globalMiddleware = [
+  ${nitro$1.routing.globalMiddleware.map((h) => h.lazy ? h._importHash : `h3.toEventHandler(${h._importHash})`).join(",")}
+].filter(Boolean);
+  `;
+		}
+	};
+}
+function uniqueBy(arr, key) {
+	return [...new Map(arr.map((item) => [item[key], item])).values()];
+}
+function serializeHandler(h) {
+	const meta = Array.isArray(h) ? h[0] : h;
+	return `{${[
+		`route:${JSON.stringify(meta.route)}`,
+		meta.method && `method:${JSON.stringify(meta.method)}`,
+		meta.meta && `meta:${JSON.stringify(meta.meta)}`,
+		`handler:${Array.isArray(h) ? `multiHandler(${h.map((handler) => serializeHandlerFn(handler)).join(",")})` : serializeHandlerFn(h)}`
+	].filter(Boolean).join(",")}}`;
+}
+function serializeHandlerFn(h) {
+	let code = h._importHash;
+	if (!h.lazy) {
+		if (h.format === "node") code = `srvxNode.toFetchHandler(${code})`;
+		code = `h3.toEventHandler(${code})`;
+	}
+	return code;
+}
+function serializeRouteRule(h) {
+	return `[${Object.entries(h).filter(([name, options]) => options !== void 0 && name[0] !== "_").map(([name, options]) => {
+		return `{${[
+			`name:${JSON.stringify(name)}`,
+			`route:${JSON.stringify(h._route)}`,
+			h._method && `method:${JSON.stringify(h._method)}`,
+			RuntimeRouteRules.includes(name) && `handler:__routeRules__.${name}`,
+			`options:${JSON.stringify(options)}`
+		].filter(Boolean).join(",")}}`;
+	}).join(",")}]`;
+}
+
+//#endregion
+//#region src/build/virtual/runtime-config.ts
+function runtimeConfig(nitro$1) {
+	return {
+		id: "#nitro/virtual/runtime-config",
+		template: () => {
+			return `export const runtimeConfig = ${JSON.stringify(nitro$1.options.runtimeConfig || {})};`;
+		}
+	};
+}
+
+//#endregion
+//#region src/build/virtual/server-assets.ts
+function serverAssets(nitro$1) {
+	return {
+		id: "#nitro/virtual/server-assets",
+		template: async () => {
+			if (nitro$1.options.dev || nitro$1.options.preset === "nitro-prerender") return `
+          import { createStorage } from 'unstorage'
+          import fsDriver from 'unstorage/drivers/fs'
+          const serverAssets = ${JSON.stringify(nitro$1.options.serverAssets)}
+          export const assets = createStorage()
+          for (const asset of serverAssets) {
+            assets.mount(asset.baseName, fsDriver({ base: asset.dir, ignore: (asset?.ignore || []) }))
+          }`;
+			const assets = {};
+			for (const asset of nitro$1.options.serverAssets) {
+				const files = await glob(asset.pattern || "**/*", {
+					cwd: asset.dir,
+					absolute: false,
+					ignore: asset.ignore
+				});
+				for (const _id of files) {
+					const fsPath = resolve$1(asset.dir, _id);
+					const id = asset.baseName + "/" + _id;
+					assets[id] = {
+						fsPath,
+						meta: {}
+					};
+					let type = src_default.getType(id) || "text/plain";
+					if (type.startsWith("text")) type += "; charset=utf-8";
+					const etag = (0, import_etag.default)(await promises.readFile(fsPath));
+					const mtime = await promises.stat(fsPath).then((s) => s.mtime.toJSON());
+					assets[id].meta = {
+						type,
+						etag,
+						mtime
+					};
+				}
+			}
+			return `
+const _assets = {\n${Object.entries(assets).map(([id, asset]) => `  [${JSON.stringify(normalizeKey(id))}]: {\n    import: () => import(${JSON.stringify("raw:" + asset.fsPath)}).then(r => r.default || r),\n    meta: ${JSON.stringify(asset.meta)}\n  }`).join(",\n")}\n}
+
+const normalizeKey = ${normalizeKey.toString()}
+
+export const assets = {
+  getKeys() {
+    return Promise.resolve(Object.keys(_assets))
+  },
+  hasItem (id) {
+    id = normalizeKey(id)
+    return Promise.resolve(id in _assets)
+  },
+  getItem (id) {
+    id = normalizeKey(id)
+    return Promise.resolve(_assets[id] ? _assets[id].import() : null)
+  },
+  getMeta (id) {
+    id = normalizeKey(id)
+    return Promise.resolve(_assets[id] ? _assets[id].meta : {})
+  }
+}
+`;
+		}
+	};
+}
+
+//#endregion
+//#region src/build/virtual/storage.ts
+function storage(nitro$1) {
+	return {
+		id: "#nitro/virtual/storage",
+		template: () => {
+			const mounts = [];
+			const storageMounts = nitro$1.options.dev || nitro$1.options.preset === "nitro-prerender" ? {
+				...nitro$1.options.storage,
+				...nitro$1.options.devStorage
+			} : nitro$1.options.storage;
+			for (const path$1 in storageMounts) {
+				const { driver: driverName, ...driverOpts } = storageMounts[path$1];
+				mounts.push({
+					path: path$1,
+					driver: builtinDrivers[driverName] || driverName,
+					opts: driverOpts
+				});
+			}
+			return `
+import { createStorage } from 'unstorage'
+import { assets } from '#nitro/virtual/server-assets'
+
+${[...new Set(mounts.map((m) => m.driver))].map((i) => genImport(i, genSafeVariableName(i))).join("\n")}
+
+export function initStorage() {
+  const storage = createStorage({})
+  storage.mount('/assets', assets)
+  ${mounts.map((m) => `storage.mount('${m.path}', ${genSafeVariableName(m.driver)}(${JSON.stringify(m.opts)}))`).join("\n")}
+  return storage
+}
+`;
+		}
+	};
+}
+
+//#endregion
+//#region src/build/virtual/tasks.ts
+function tasks(nitro$1) {
+	return {
+		id: "#nitro/virtual/tasks",
+		template: () => {
+			const _scheduledTasks = Object.entries(nitro$1.options.scheduledTasks || {}).map(([cron, _tasks]) => {
+				return {
+					cron,
+					tasks: (Array.isArray(_tasks) ? _tasks : [_tasks]).filter((name) => {
+						if (!nitro$1.options.tasks[name]) {
+							nitro$1.logger.warn(`Scheduled task \`${name}\` is not defined!`);
+							return false;
+						}
+						return true;
+					})
+				};
+			}).filter((e) => e.tasks.length > 0);
+			const scheduledTasks = _scheduledTasks.length > 0 ? _scheduledTasks : false;
+			return `
+export const scheduledTasks = ${JSON.stringify(scheduledTasks)};
+
+export const tasks = {
+  ${Object.entries(nitro$1.options.tasks).map(([name, task]) => `"${name}": {
+          meta: {
+            description: ${JSON.stringify(task.description)},
+          },
+          resolve: ${task.handler ? `() => import("${normalize$1(task.handler)}").then(r => r.default || r)` : "undefined"},
+        }`).join(",\n")}
+};`;
+		}
+	};
+}
+
+//#endregion
+//#region src/build/virtual/_all.ts
+function virtualTemplates(nitro$1, _polyfills) {
+	const nitroTemplates = [
+		database,
+		errorHandler,
+		featureFlags,
+		plugins,
+		polyfills,
+		publicAssets,
+		rendererTemplate,
+		routingMeta,
+		routing,
+		runtimeConfig,
+		serverAssets,
+		storage,
+		tasks
+	].flatMap((t) => t(nitro$1, _polyfills));
+	const customTemplates = Object.entries(nitro$1.options.virtual).map(([id, template]) => ({
+		id,
+		template
+	}));
+	return [...nitroTemplates, ...customTemplates];
+}
+
+//#endregion
+//#region src/build/plugins/route-meta.ts
+const PREFIX$1 = "\0nitro:route-meta:";
+function routeMeta(nitro$1) {
+	return {
+		name: "nitro:route-meta",
+		resolveId: {
+			filter: { id: /^(?!\u0000)(.+)\?meta$/ },
+			async handler(id, importer, resolveOpts) {
+				if (id.endsWith("?meta")) {
+					const resolved = await this.resolve(id.replace("?meta", ""), importer, resolveOpts);
+					if (!resolved) return;
+					return PREFIX$1 + resolved.id;
+				}
+			}
+		},
+		load: {
+			filter: { id: /* @__PURE__ */ new RegExp(`^${escapeRegExp(PREFIX$1)}`) },
+			handler(id) {
+				if (id.startsWith(PREFIX$1)) {
+					const fullPath = id.slice(18);
+					if (isAbsolute$1(fullPath)) return readFile(fullPath, { encoding: "utf8" });
+					else return "export default undefined;";
+				}
+			}
+		},
+		transform: {
+			filter: { id: /* @__PURE__ */ new RegExp(`^${escapeRegExp(PREFIX$1)}`) },
+			async handler(code, id) {
+				let meta = null;
+				try {
+					const transformRes = transformSync(id, code);
+					if (transformRes.errors?.length > 0) {
+						for (const error of transformRes.errors) this.warn(error);
+						return {
+							code: `export default {};`,
+							map: null
+						};
+					}
+					const ast = this.parse(transformRes.code);
+					for (const node of ast.body) if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier" && node.expression.callee.name === "defineRouteMeta" && node.expression.arguments.length === 1) {
+						meta = astToObject(node.expression.arguments[0]);
+						break;
+					}
+				} catch (error) {
+					nitro$1.logger.warn(`[handlers-meta] Cannot extra route meta for: ${id}: ${error}`);
+				}
+				return {
+					code: `export default ${JSON.stringify(meta)};`,
+					map: null
+				};
+			}
+		}
+	};
+}
+function astToObject(node) {
+	switch (node.type) {
+		case "ObjectExpression": {
+			const obj = {};
+			for (const prop of node.properties) if (prop.type === "Property") {
+				const key = prop.key.name ?? prop.key.value;
+				obj[key] = astToObject(prop.value);
+			}
+			return obj;
+		}
+		case "ArrayExpression": return node.elements.map((el) => astToObject(el)).filter((obj) => obj !== void 0);
+		case "Literal": return node.value;
+	}
+}
+
+//#endregion
+//#region src/build/plugins/server-main.ts
+function serverMain(nitro$1) {
+	return {
+		name: "nitro:server-main",
+		renderChunk(code, chunk) {
+			if (chunk.isEntry) return {
+				code: `globalThis.__nitro_main__ = import.meta.url; ${code}`,
+				map: null
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/build/plugins/virtual.ts
+function virtual(input) {
+	const modules = /* @__PURE__ */ new Map();
+	for (const mod of input) {
+		const render = () => typeof mod.template === "function" ? mod.template() : mod.template;
+		modules.set(mod.id, {
+			module: mod,
+			render
+		});
+	}
+	const include = [/^#nitro\/virtual/];
+	const extraIds = [...modules.keys()].filter((key) => !key.startsWith("#nitro/virtual"));
+	if (extraIds.length > 0) include.push(/* @__PURE__ */ new RegExp(`^(${extraIds.map((id) => pathRegExp(id)).join("|")})$`));
+	return {
+		name: "nitro:virtual",
+		api: { modules },
+		resolveId: {
+			order: "pre",
+			filter: { id: include },
+			handler: (id) => {
+				const mod = modules.get(id);
+				if (mod) return {
+					id,
+					moduleSideEffects: mod.module.moduleSideEffects ?? false
+				};
+			}
+		},
+		load: {
+			order: "pre",
+			filter: { id: include },
+			handler: async (id) => {
+				const mod = modules.get(id);
+				if (!mod) throw new Error(`Virtual module ${id} not found.`);
+				return {
+					code: await mod.render(),
+					map: null
+				};
+			}
+		}
+	};
+}
+function virtualDeps() {
+	const cache = /* @__PURE__ */ new Map();
+	return {
+		name: "nitro:virtual-deps",
+		resolveId: {
+			order: "pre",
+			filter: { id: /* @__PURE__ */ new RegExp(`^(#nitro|${runtimeDependencies.map((dep) => pathRegExp(dep)).join("|")})`) },
+			handler(id, importer) {
+				if (!importer || !importer.startsWith("#nitro/virtual")) return;
+				let resolved = cache.get(id);
+				if (!resolved) resolved = this.resolve(id, runtimeDir).then((_resolved) => {
+					cache.set(id, _resolved);
+					return _resolved;
+				}).catch((error) => {
+					cache.delete(id);
+					throw error;
+				});
+				return resolved;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/build/plugins/sourcemap-min.ts
+function sourcemapMinify() {
+	return {
+		name: "nitro:sourcemap-minify",
+		generateBundle(_options, bundle) {
+			for (const [key, asset] of Object.entries(bundle)) {
+				if (!key.endsWith(".map") || !("source" in asset) || typeof asset.source !== "string") continue;
+				const sourcemap = JSON.parse(asset.source);
+				delete sourcemap.sourcesContent;
+				delete sourcemap.x_google_ignoreList;
+				if ((sourcemap.sources || []).some((s) => s.includes("node_modules"))) sourcemap.mappings = "";
+				asset.source = JSON.stringify(sourcemap);
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/build/plugins/raw.ts
+const HELPER_ID = "\0nitro-raw-helpers";
+const RESOLVED_PREFIX = "\0nitro:raw:";
+const PREFIX = "raw:";
+function raw() {
+	return {
+		name: "nitro:raw",
+		resolveId: {
+			order: "pre",
+			filter: { id: [/* @__PURE__ */ new RegExp(`^${HELPER_ID}$`), /* @__PURE__ */ new RegExp(`^${PREFIX}`)] },
+			async handler(id, importer, resolveOpts) {
+				if (id === HELPER_ID) return id;
+				if (id.startsWith(PREFIX)) {
+					const resolvedId = (await this.resolve(id.slice(4), importer, resolveOpts))?.id;
+					if (!resolvedId) return null;
+					return { id: RESOLVED_PREFIX + resolvedId };
+				}
+			}
+		},
+		load: {
+			order: "pre",
+			filter: { id: [/* @__PURE__ */ new RegExp(`^${HELPER_ID}$`), /* @__PURE__ */ new RegExp(`^${RESOLVED_PREFIX}`)] },
+			handler(id) {
+				if (id === HELPER_ID) return getHelpers();
+				if (id.startsWith(RESOLVED_PREFIX)) return promises.readFile(id.slice(11), isBinary(id) ? "binary" : "utf8");
+			}
+		},
+		transform: {
+			order: "pre",
+			filter: { id: /* @__PURE__ */ new RegExp(`^${RESOLVED_PREFIX}`) },
+			handler(code, id) {
+				const path$1 = id.slice(11);
+				if (isBinary(id)) return {
+					code: `import {base64ToUint8Array } from "${HELPER_ID}" \n export default base64ToUint8Array("${Buffer.from(code, "binary").toString("base64")}")`,
+					map: rawAssetMap(path$1)
+				};
+				return {
+					code: `export default ${JSON.stringify(code)}`,
+					map: rawAssetMap(path$1),
+					moduleType: "js"
+				};
+			}
+		}
+	};
+}
+function isBinary(id) {
+	const idMime = src_default.getType(id) || "";
+	if (idMime.startsWith("text/")) return false;
+	if (/application\/(json|sql|xml|yaml)/.test(idMime)) return false;
+	return true;
+}
+function getHelpers() {
+	return `
+export function base64ToUint8Array(str) {
+  const data = atob(str);
+  const size = data.length;
+  const bytes = new Uint8Array(size);
+  for (let i = 0; i < size; i++) {
+    bytes[i] = data.charCodeAt(i);
+  }
+  return bytes;
+}
+  `;
+}
+function rawAssetMap(id) {
+	return {
+		version: 3,
+		file: id,
+		sources: [id],
+		sourcesContent: [],
+		names: [],
+		mappings: ""
+	};
+}
+
+//#endregion
+//#region src/build/plugins/externals.ts
+const PLUGIN_NAME = "nitro:externals";
+function externals(opts) {
+	const include = opts?.include ? opts.include.map((p) => toPathRegExp(p)) : void 0;
+	const exclude = [/^(?:[\0#~.]|[a-z0-9]{2,}:)|\?/, ...(opts?.exclude || []).map((p) => toPathRegExp(p))];
+	const filter = (id) => {
+		if (include && !include.some((r) => r.test(id))) return false;
+		if (exclude.some((r) => r.test(id))) return false;
+		return true;
+	};
+	const tryResolve$1 = (id, from) => resolveModulePath(id, {
+		try: true,
+		from: from && isAbsolute$1(from) ? from : opts.rootDir,
+		conditions: opts.conditions
+	});
+	const tracedPaths = /* @__PURE__ */ new Set();
+	if (include && include.length === 0) return { name: PLUGIN_NAME };
+	return {
+		name: PLUGIN_NAME,
+		resolveId: {
+			order: "pre",
+			filter: { id: {
+				exclude,
+				include
+			} },
+			async handler(id, importer, rOpts) {
+				if (builtinModules.includes(id)) return {
+					resolvedBy: PLUGIN_NAME,
+					external: true,
+					id: id.includes(":") ? id : `node:${id}`
+				};
+				if (rOpts.custom?.["node-resolve"]) return null;
+				let resolved = await this.resolve(id, importer, rOpts);
+				const cjsResolved = resolved?.meta?.commonjs?.resolved;
+				if (cjsResolved) {
+					if (!filter(cjsResolved.id)) return resolved;
+					resolved = cjsResolved;
+				}
+				if (!resolved?.id || !filter(resolved.id)) return resolved;
+				let resolvedPath = resolved.id;
+				if (!isAbsolute$1(resolvedPath)) resolvedPath = tryResolve$1(resolvedPath, importer) || resolvedPath;
+				if (opts.trace) {
+					let importId = toImport(id) || toImport(resolvedPath);
+					if (!importId) return resolved;
+					if (!tryResolve$1(importId, importer)) {
+						const guessed = await guessSubpath(resolvedPath, opts.conditions);
+						if (!guessed) return resolved;
+						importId = guessed;
+					}
+					tracedPaths.add(resolvedPath);
+					return {
+						...resolved,
+						resolvedBy: PLUGIN_NAME,
+						external: true,
+						id: importId
+					};
+				}
+				return {
+					...resolved,
+					resolvedBy: PLUGIN_NAME,
+					external: true,
+					id: isAbsolute$1(resolvedPath) ? pathToFileURL(resolvedPath).href : resolvedPath
+				};
+			}
+		},
+		buildEnd: {
+			order: "post",
+			async handler() {
+				if (!opts.trace || tracedPaths.size === 0) return;
+				const { traceNodeModules } = await import("nf3");
+				const traceTime = Date.now();
+				let traceFilesCount = 0;
+				let tracedPkgsCount = 0;
+				await traceNodeModules([...tracedPaths], {
+					...opts.trace,
+					conditions: opts.conditions,
+					rootDir: opts.rootDir,
+					writePackageJson: true,
+					hooks: {
+						tracedFiles(result) {
+							traceFilesCount = Object.keys(result).length;
+						},
+						tracedPackages: (pkgs) => {
+							tracedPkgsCount = Object.keys(pkgs).length;
+							consola$1.info(`Tracing dependencies:\n${Object.entries(pkgs).map(([name, versions]) => `- \`${name}\` (${Object.keys(versions.versions).join(", ")})`).join("\n")}`);
+						}
+					}
+				});
+				consola$1.success(`Traced ${tracedPkgsCount} dependencies (${traceFilesCount} files) in ${Date.now() - traceTime}ms.`);
+				consola$1.info(`Ensure your production environment matches the builder OS and architecture (\`${process.platform}-${process.arch}\`) to avoid native module issues.`);
+			}
+		}
+	};
+}
+const NODE_MODULES_RE = /^(?<dir>.+[\\/]node_modules[\\/])(?<name>[^@\\/]+|@[^\\/]+[\\/][^\\/]+)(?:[\\/](?<subpath>.+))?$/;
+const IMPORT_RE = /^(?!\.)(?<name>[^@/\\]+|@[^/\\]+[/\\][^/\\]+)(?:[/\\](?<subpath>.+))?$/;
+function toImport(id) {
+	if (isAbsolute$1(id)) {
+		const { name, subpath } = NODE_MODULES_RE.exec(id)?.groups || {};
+		if (name && subpath) return join$1(name, subpath);
+	} else if (IMPORT_RE.test(id)) return id;
+}
+function guessSubpath(path$1, conditions) {
+	const { dir, name, subpath } = NODE_MODULES_RE.exec(path$1)?.groups || {};
+	if (!dir || !name || !subpath) return;
+	const exports = getPkgJSON(join$1(dir, name) + "/")?.exports;
+	if (!exports || typeof exports !== "object") return;
+	for (const e of flattenExports(exports)) {
+		if (!conditions.includes(e.condition || "default")) continue;
+		if (e.fsPath === subpath) return join$1(name, e.subpath);
+		if (e.fsPath.includes("*")) {
+			const fsPathRe = /* @__PURE__ */ new RegExp("^" + escapeRegExp(e.fsPath).replace(String.raw`\*`, "(.+?)") + "$");
+			if (fsPathRe.test(subpath)) {
+				const matched = fsPathRe.exec(subpath)?.[1];
+				if (matched) return join$1(name, e.subpath.replace("*", matched));
+			}
+		}
+	}
+}
+function getPkgJSON(dir) {
+	const cache = getPkgJSON._cache ||= /* @__PURE__ */ new Map();
+	if (cache.has(dir)) return cache.get(dir);
+	try {
+		const pkg = createRequire(dir)("./package.json");
+		cache.set(dir, pkg);
+		return pkg;
+	} catch {}
+}
+function flattenExports(exports = {}, parentSubpath = "./") {
+	return Object.entries(exports).flatMap(([key, value]) => {
+		const [subpath, condition] = key.startsWith(".") ? [key.slice(1)] : [void 0, key];
+		const _subPath = join$1(parentSubpath, subpath || "");
+		if (typeof value === "string") return [{
+			subpath: _subPath,
+			fsPath: value.replace(/^\.\//, ""),
+			condition
+		}];
+		return typeof value === "object" ? flattenExports(value, _subPath) : [];
+	});
+}
+
+//#endregion
+//#region src/build/plugins.ts
+async function baseBuildPlugins(nitro$1, base) {
+	const plugins$1 = [];
+	const virtualPlugin = virtual(virtualTemplates(nitro$1, [...base.env.polyfill]));
+	nitro$1.vfs = virtualPlugin.api.modules;
+	plugins$1.push(virtualPlugin, virtualDeps());
+	if (nitro$1.options.imports) {
+		const unimportPlugin = await import("./_libs/unimport.mjs").then((n) => n.i);
+		plugins$1.push(unimportPlugin.default.rollup(nitro$1.options.imports));
+	}
+	if (nitro$1.options.wasm !== false) plugins$1.push(unwasm(nitro$1.options.wasm || {}));
+	plugins$1.push(serverMain(nitro$1));
+	plugins$1.push(raw());
+	if (nitro$1.options.experimental.openAPI) plugins$1.push(routeMeta(nitro$1));
+	plugins$1.push(replace({
+		preventAssignment: true,
+		values: base.replacements
+	}));
+	if (nitro$1.options.node && nitro$1.options.noExternals !== true) {
+		const isDevOrPrerender = nitro$1.options.dev || nitro$1.options.preset === "nitro-prerender";
+		const traceDeps = [...new Set([...NodeNativePackages, ...nitro$1.options.traceDeps || []])];
+		plugins$1.push(externals({
+			rootDir: nitro$1.options.rootDir,
+			conditions: nitro$1.options.exportConditions || ["default"],
+			exclude: [...base.noExternal],
+			include: isDevOrPrerender ? void 0 : [/* @__PURE__ */ new RegExp(`^(?:${traceDeps.join("|")})|[/\\\\]node_modules[/\\\\](?:${traceDeps.join("|")})(?:[/\\\\])`)],
+			trace: isDevOrPrerender ? false : { outDir: nitro$1.options.output.serverDir }
+		}));
+	}
+	if (nitro$1.options.sourcemap && !nitro$1.options.dev && nitro$1.options.experimental.sourcemapMinify !== false) plugins$1.push(sourcemapMinify());
+	return plugins$1;
+}
+
+//#endregion
+//#region src/build/vite/rollup.ts
+const getViteRollupConfig = async (ctx) => {
+	const nitro$1 = ctx.nitro;
+	const base = baseBuildConfig(nitro$1);
+	let config = {
+		input: nitro$1.options.entry,
+		external: [...base.env.external],
+		plugins: [
+			...await baseBuildPlugins(nitro$1, base),
+			alias({ entries: base.aliases }),
+			!ctx._isRolldown && inject(base.env.inject)
+		].filter(Boolean),
+		...ctx._isRolldown ? { transform: { inject: base.env.inject } } : {},
+		treeshake: { moduleSideEffects(id) {
+			return nitro$1.options.moduleSideEffects.some((p) => id.startsWith(p));
+		} },
+		onwarn(warning, warn) {
+			if (!base.ignoreWarningCodes.has(warning.code || "")) warn(warning);
+		},
+		output: {
+			format: "esm",
+			entryFileNames: "index.mjs",
+			chunkFileNames: (chunk) => getChunkName(chunk, nitro$1),
+			...ctx._isRolldown ? { advancedChunks: { groups: [{
+				test: NODE_MODULES_RE$1,
+				name: (id) => libChunkName(id)
+			}] } } : { manualChunks(id) {
+				if (NODE_MODULES_RE$1.test(id)) return libChunkName(id);
+			} },
+			inlineDynamicImports: nitro$1.options.inlineDynamicImports,
+			dir: nitro$1.options.output.serverDir,
+			generatedCode: { ...ctx._isRolldown ? {} : { constBindings: true } },
+			...ctx._isRolldown ? {} : { sourcemapExcludeSources: true },
+			sourcemapIgnoreList: (id) => id.includes("node_modules")
+		}
+	};
+	config = defu(nitro$1.options.rollupConfig, config);
+	return {
+		config,
+		base
+	};
+};
+
+//#endregion
+//#region src/build/vite/prod.ts
+const BuilderNames = {
+	nitro: colors.magenta("Nitro"),
+	client: colors.green("Client"),
+	ssr: colors.blue("SSR")
+};
+async function buildEnvironments(ctx, builder) {
+	const nitro$1 = ctx.nitro;
+	for (const [envName, env] of Object.entries(builder.environments)) {
+		const fmtName = BuilderNames[envName] || (envName.length <= 3 ? envName.toUpperCase() : envName[0].toUpperCase() + envName.slice(1));
+		if (envName === "nitro" || !env.config.build.rollupOptions.input || env.isBuilt) {
+			if (![
+				"nitro",
+				"ssr",
+				"client"
+			].includes(envName)) nitro$1.logger.info(env.isBuilt ? `Skipping ${fmtName} (already built)` : `Skipping ${fmtName} (no input defined)`);
+			continue;
+		}
+		if (!a && !T) console.log();
+		nitro$1.logger.start(`Building [${fmtName}]`);
+		await builder.build(env);
+	}
+	const nitroOptions = ctx.nitro.options;
+	const clientInput = builder.environments.client?.config?.build?.rollupOptions?.input;
+	if (nitroOptions.renderer?.template && nitroOptions.renderer?.template === clientInput) {
+		const outputPath = resolve$1(nitroOptions.output.publicDir, basename$1(clientInput));
+		if (existsSync(outputPath)) {
+			const html = await readFile(outputPath, "utf8").then((r) => r.replace("<!--ssr-outlet-->", `{{{ globalThis.__nitro_vite_envs__?.["ssr"]?.fetch($REQUEST) || "" }}}`));
+			await rm(outputPath);
+			const tmp = resolve$1(nitroOptions.buildDir, "vite/index.html");
+			await mkdir(dirname$1(tmp), { recursive: true });
+			await writeFile(tmp, html, "utf8");
+			nitroOptions.renderer.template = tmp;
+		}
+	}
+	await builder.writeAssetsManifest?.();
+	if (!a && !T) console.log();
+	const buildInfo = [["preset", nitro$1.options.preset], ["compatibility", formatCompatibilityDate(nitro$1.options.compatibilityDate)]].filter((e) => e[1]);
+	nitro$1.logger.start(`Building [${BuilderNames.nitro}] ${colors.dim(`(${buildInfo.map(([k, v]) => `${k}: \`${v}\``).join(", ")})`)}`);
+	await copyPublicAssets(nitro$1);
+	const assetDirs = new Set(Object.values(builder.environments).filter((env) => env.config.consumer === "client").map((env) => env.config.build.assetsDir).filter(Boolean));
+	for (const assetsDir of assetDirs) {
+		if (!existsSync(resolve$1(nitro$1.options.output.publicDir, assetsDir))) continue;
+		const rule = ctx.nitro.options.routeRules[`/${assetsDir}/**`] ??= {};
+		if (!rule.headers?.["cache-control"]) rule.headers = {
+			...rule.headers,
+			"cache-control": `public, max-age=31536000, immutable`
+		};
+	}
+	ctx.nitro.routing.sync();
+	await builder.build(builder.environments.nitro);
+	await nitro$1.close();
+	await nitro$1.hooks.callHook("compiled", nitro$1);
+	await writeBuildInfo(nitro$1);
+	const rOutput = relative$1(process.cwd(), nitro$1.options.output.dir);
+	const rewriteRelativePaths = (input) => {
+		return input.replace(/([\s:])\.\/(\S*)/g, `$1${rOutput}/$2`);
+	};
+	if (!a && !T) console.log();
+	if (nitro$1.options.commands.preview) nitro$1.logger.success(`You can preview this build using \`${rewriteRelativePaths(nitro$1.options.commands.preview)}\``);
+	if (nitro$1.options.commands.deploy) nitro$1.logger.success(`You can deploy this build using \`${rewriteRelativePaths(nitro$1.options.commands.deploy)}\``);
+}
+function prodSetup(ctx) {
+	return `
+function lazyService(loader) {
+  let promise, mod
+  return {
+    fetch(req) {
+      if (mod) { return mod.fetch(req) }
+      if (!promise) {
+        promise = loader().then(_mod => (mod = _mod.default || _mod))
+      }
+      return promise.then(mod => mod.fetch(req))
+    }
+  }
+}
+
+const services = {
+${Object.keys(ctx.services).map((name) => {
+		return [name, resolve$1(ctx.nitro.options.buildDir, "vite/services", name, ctx._entryPoints[name])];
+	}).map(([name, entry]) => `[${JSON.stringify(name)}]: lazyService(() => import(${JSON.stringify(entry)}))`).join(",\n")}
+};
+
+globalThis.__nitro_vite_envs__ = services;
+  `;
+}
+
+//#endregion
+//#region src/build/vite/dev.ts
+function createFetchableDevEnvironment(name, config, devServer, entry) {
+	return new FetchableDevEnvironment(name, config, {
+		hot: true,
+		transport: createTransport(name, devServer)
+	}, devServer, entry);
+}
+var FetchableDevEnvironment = class extends DevEnvironment {
+	devServer;
+	constructor(name, config, context, devServer, entry) {
+		super(name, config, context);
+		this.devServer = devServer;
+		this.devServer.sendMessage({
+			type: "custom",
+			event: "nitro:vite-env",
+			data: {
+				name,
+				entry
+			}
+		});
+	}
+	async dispatchFetch(request) {
+		return this.devServer.fetch(request);
+	}
+	async init(...args) {
+		await this.devServer.init?.();
+		return super.init(...args);
+	}
+};
+function createTransport(name, hooks) {
+	const listeners = /* @__PURE__ */ new WeakMap();
+	return {
+		send: (data) => hooks.sendMessage({
+			...data,
+			viteEnv: name
+		}),
+		on: (event, handler) => {
+			if (event === "connection") return;
+			const listener = (value) => {
+				if (value?.type === "custom" && value.event === event && value.viteEnv === name) handler(value.data, { send: (payload) => hooks.sendMessage({
+					...payload,
+					viteEnv: name
+				}) });
+			};
+			listeners.set(handler, listener);
+			hooks.onMessage(listener);
+		},
+		off: (event, handler) => {
+			if (event === "connection") return;
+			const listener = listeners.get(handler);
+			if (listener) {
+				hooks.offMessage(listener);
+				listeners.delete(handler);
+			}
+		}
+	};
+}
+async function configureViteDevServer(ctx, server) {
+	const nitro$1 = ctx.nitro;
+	const nitroEnv$1 = server.environments.nitro;
+	const nitroConfigFile = nitro$1.options._c12.configFile;
+	if (nitroConfigFile) server.config.configFileDependencies.push(nitroConfigFile);
+	if (nitro$1.options.features.websocket ?? nitro$1.options.experimental.websocket) server.httpServer.on("upgrade", (req, socket, head) => {
+		if (req.url?.startsWith("/?token")) return;
+		getEnvRunner(ctx).upgrade?.(req, socket, head);
+	});
+	const reload = debounce(async () => {
+		await scanHandlers(nitro$1);
+		nitro$1.routing.sync();
+		nitroEnv$1.moduleGraph.invalidateAll();
+		nitroEnv$1.hot.send({ type: "full-reload" });
+	});
+	const scanDirs = nitro$1.options.scanDirs.flatMap((dir) => [
+		join$1(dir, nitro$1.options.apiDir || "api"),
+		join$1(dir, nitro$1.options.routesDir || "routes"),
+		join$1(dir, "middleware"),
+		join$1(dir, "plugins"),
+		join$1(dir, "modules")
+	]);
+	const watchReloadEvents = new Set([
+		"add",
+		"addDir",
+		"unlink",
+		"unlinkDir"
+	]);
+	const scanDirsWatcher = watch$1(scanDirs, { ignoreInitial: true }).on("all", (event, path$1, stat$2) => {
+		if (watchReloadEvents.has(event)) reload();
+	});
+	const rootDirWatcher = watch(nitro$1.options.rootDir, { persistent: false }, (_event, filename) => {
+		if (filename && /^server\.[mc]?[jt]sx?$/.test(filename)) reload();
+	});
+	nitro$1.hooks.hook("close", () => {
+		scanDirsWatcher.close();
+		rootDirWatcher.close();
+	});
+	const hostIPC = { async transformHTML(html) {
+		return server.transformIndexHtml("/", html).then((r) => r.replace("<!--ssr-outlet-->", `{{{ globalThis.__nitro_vite_envs__?.["ssr"]?.fetch($REQUEST) || "" }}}`));
+	} };
+	nitroEnv$1.devServer.onMessage(async (payload) => {
+		if (payload.type === "custom" && payload.event === "nitro:vite-invoke") {
+			const res = await hostIPC[payload.data.name](payload.data.data).then((data) => ({ data })).catch((error) => ({ error }));
+			nitroEnv$1.devServer.sendMessage({
+				type: "custom",
+				event: "nitro:vite-invoke-response",
+				data: {
+					id: payload.data.id,
+					data: res
+				}
+			});
+		}
+	});
+	const nitroDevMiddleware = async (nodeReq, nodeRes, next) => {
+		if (!nodeReq.url || /^\/@(?:vite|fs|id)\//.test(nodeReq.url) || nodeReq._nitroHandled || server.middlewares.stack.map((mw) => mw.route).some((base) => base && nodeReq.url.startsWith(base))) return next();
+		nodeReq._nitroHandled = true;
+		try {
+			const req = new NodeRequest({
+				req: nodeReq,
+				res: nodeRes
+			});
+			const devAppRes = await ctx.devApp.fetch(req);
+			if (nodeRes.writableEnded || nodeRes.headersSent) return;
+			if (devAppRes.status !== 404) return await sendNodeResponse(nodeRes, devAppRes);
+			const envRes = await nitroEnv$1.dispatchFetch(req);
+			if (nodeRes.writableEnded || nodeRes.headersSent) return;
+			return await sendNodeResponse(nodeRes, envRes);
+		} catch (error) {
+			return next(error);
+		}
+	};
+	server.middlewares.use(function nitroDevMiddlewarePre(req, res, next) {
+		const fetchDest = req.headers["sec-fetch-dest"];
+		res.setHeader("vary", "sec-fetch-dest");
+		if ((!fetchDest || /^(document|iframe|frame|empty)$/.test(fetchDest)) && !req.url.match(/\.([a-z0-9]+)(?:[?#]|$)/i)?.[1] && !/^\/(?:__|@)/.test(req.url)) nitroDevMiddleware(req, res, next);
+		else next();
+	});
+	return () => {
+		server.middlewares.use(nitroDevMiddleware);
+	};
+}
+
+//#endregion
+//#region src/build/vite/env.ts
+function getEnvRunner(ctx) {
+	return ctx._envRunner ??= new NodeEnvRunner({
+		name: "nitro-vite",
+		entry: resolve(runtimeDir, "internal/vite/node-runner.mjs"),
+		data: { server: true }
+	});
+}
+function createNitroEnvironment(ctx) {
+	return {
+		consumer: "server",
+		build: {
+			rollupOptions: ctx.rollupConfig.config,
+			minify: ctx.nitro.options.minify,
+			emptyOutDir: false,
+			sourcemap: ctx.nitro.options.sourcemap,
+			commonjsOptions: ctx.nitro.options.commonJS
+		},
+		resolve: {
+			noExternal: ctx.nitro.options.dev ? [
+				/^nitro$/,
+				/* @__PURE__ */ new RegExp(`^(${runtimeDependencies.join("|")})$`),
+				...ctx.rollupConfig.base.noExternal
+			] : true,
+			conditions: 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: (envName, envConfig) => createFetchableDevEnvironment(envName, envConfig, getEnvRunner(ctx), resolve(runtimeDir, "internal/vite/dev-entry.mjs")) }
+	};
+}
+function createServiceEnvironment(ctx, name, serviceConfig) {
+	return {
+		consumer: "server",
+		build: {
+			rollupOptions: { input: { index: serviceConfig.entry } },
+			minify: ctx.nitro.options.minify,
+			sourcemap: ctx.nitro.options.sourcemap,
+			outDir: join(ctx.nitro.options.buildDir, "vite/services", name),
+			emptyOutDir: true
+		},
+		resolve: {
+			conditions: ctx.nitro.options.exportConditions,
+			externalConditions: ctx.nitro.options.exportConditions?.filter((c) => !/browser|wasm|module/.test(c))
+		},
+		dev: { createEnvironment: (envName, envConfig) => createFetchableDevEnvironment(envName, envConfig, getEnvRunner(ctx), tryResolve(serviceConfig.entry)) }
+	};
+}
+function createServiceEnvironments(ctx) {
+	return Object.fromEntries(Object.entries(ctx.services).map(([name, config]) => [name, createServiceEnvironment(ctx, name, config)]));
+}
+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;
+}
+
+//#endregion
+//#region src/build/vite/preview.ts
+function nitroPreviewPlugin(ctx) {
+	return {
+		name: "nitro:preview",
+		apply: (_config, configEnv) => !!configEnv.isPreview,
+		config(config) {
+			return { preview: { port: config.preview?.port || 3e3 } };
+		},
+		async configurePreviewServer(server) {
+			const { outputDir, buildInfo } = await getBuildInfo(server.config.root);
+			if (!buildInfo) throw this.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$1.box({
+				title: " [Build Info] ",
+				message: info.map((i) => `- ${i[0]} ${i[1]}`).join("\n")
+			});
+			if (!buildInfo.commands?.preview) {
+				consola$1.warn("No nitro build preview command found for this preset.");
+				return;
+			}
+			const dotEnvEntries = await loadPreviewDotEnv(server.config.root);
+			if (dotEnvEntries.length > 0) consola$1.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")
+			});
+			const [command, ...args] = buildInfo.commands.preview.split(" ");
+			consola$1.info(`Spawning preview server...`);
+			consola$1.info(buildInfo.commands?.preview);
+			console.log("");
+			const { getRandomPort, waitForPort } = await import("get-port-please");
+			const randomPort = await getRandomPort();
+			const child = spawn(command, args, {
+				stdio: "inherit",
+				cwd: outputDir,
+				env: {
+					...process.env,
+					...Object.fromEntries(dotEnvEntries),
+					PORT: String(randomPort)
+				}
+			});
+			const killChild = (signal) => {
+				if (child && !child.killed) child.kill(signal);
+			};
+			for (const sig of ["SIGINT", "SIGHUP"]) process.once(sig, () => {
+				consola$1.info(`Stopping preview server...`);
+				killChild(sig);
+				process.exit();
+			});
+			server.httpServer.once("close", () => {
+				killChild("SIGTERM");
+			});
+			child.once("exit", (code) => {
+				if (code && code !== 0) consola$1.error(`[nitro] Preview server exited with code ${code}`);
+			});
+			const { createProxyServer } = await import("./_libs/httpxy.mjs").then((n) => n.r);
+			const proxy = createProxyServer({ target: `http://localhost:${randomPort}` });
+			server.middlewares.use((req, res, next) => {
+				if (child && !child.killed) proxy.web(req, res).catch(next);
+				else res.end(`Nitro preview server is not running.`);
+			});
+			await waitForPort(randomPort, {
+				retries: 20,
+				delay: 500
+			});
+		}
+	};
+}
+async function loadPreviewDotEnv(root) {
+	const { loadDotenv } = await import("./_libs/c12.mjs").then((n) => n.n);
+	const env = await loadDotenv({
+		cwd: root,
+		fileName: [
+			".env.preview",
+			".env.production",
+			".env"
+		]
+	});
+	return Object.entries(env).filter(([_key, val]) => val);
+}
+
+//#endregion
+//#region src/build/vite/plugin.ts
+const DEFAULT_EXTENSIONS = [
+	".ts",
+	".js",
+	".mts",
+	".mjs",
+	".tsx",
+	".jsx"
+];
+const debug = process.env.NITRO_DEBUG ? (...args) => console.log("[nitro]", ...args) : () => {};
+function nitro(pluginConfig = {}) {
+	const ctx = createContext(pluginConfig);
+	return [
+		nitroInit(ctx),
+		nitroEnv(ctx),
+		nitroMain(ctx),
+		nitroPrepare(ctx),
+		nitroService(ctx),
+		nitroPreviewPlugin(ctx),
+		pluginConfig.experimental?.vite?.assetsImport !== false && assetsPlugin({ experimental: { clientBuildFallback: false } })
+	].filter(Boolean);
+}
+function nitroInit(ctx) {
+	return {
+		name: "nitro:init",
+		sharedDuringBuild: true,
+		apply: (_config, configEnv) => !configEnv.isPreview,
+		async config(config, configEnv) {
+			ctx._isRolldown = !!this.meta.rolldownVersion;
+			if (!ctx._initialized) {
+				debug("[init] Initializing nitro");
+				ctx._initialized = true;
+				await setupNitroContext(ctx, configEnv, config);
+			}
+		},
+		applyToEnvironment(env) {
+			if (env.name === "nitro" && ctx.nitro?.options.dev) {
+				debug("[init] Adding rollup plugins for dev");
+				return [...ctx.rollupConfig?.config.plugins || []];
+			}
+		}
+	};
+}
+function nitroEnv(ctx) {
+	return {
+		name: "nitro:env",
+		sharedDuringBuild: true,
+		apply: (_config, configEnv) => !configEnv.isPreview,
+		async config(userConfig, _configEnv) {
+			debug("[env]  Extending config (environments)");
+			const environments = {
+				...createServiceEnvironments(ctx),
+				nitro: createNitroEnvironment(ctx)
+			};
+			environments.client = {
+				consumer: userConfig.environments?.client?.consumer ?? "client",
+				build: { rollupOptions: { input: userConfig.environments?.client?.build?.rollupOptions?.input ?? useNitro(ctx).options.renderer?.template } }
+			};
+			debug("[env]  Environments:", Object.keys(environments).join(", "));
+			return { environments };
+		},
+		configEnvironment(name, config) {
+			if (config.consumer === "client") {
+				debug("[env]  Configuring client environment", name === "client" ? "" : ` (${name})`);
+				config.build.emptyOutDir = false;
+				config.build.outDir = useNitro(ctx).options.output.publicDir;
+			}
+		}
+	};
+}
+function nitroMain(ctx) {
+	return {
+		name: "nitro:main",
+		sharedDuringBuild: true,
+		apply: (_config, configEnv) => !configEnv.isPreview,
+		async config(userConfig, _configEnv) {
+			debug("[main] Extending config (appType, resolve, server)");
+			if (!ctx.rollupConfig) throw new Error("Nitro rollup config is not initialized yet.");
+			return {
+				appType: userConfig.appType || "custom",
+				resolve: { alias: ctx.rollupConfig.base.aliases },
+				builder: { sharedConfigBuild: true },
+				server: {
+					port: Number.parseInt(process.env.PORT || "") || userConfig.server?.port || useNitro(ctx).options.devServer?.port || 3e3,
+					cors: false
+				}
+			};
+		},
+		buildApp: {
+			order: "post",
+			handler(builder) {
+				debug("[main] Building environments");
+				return buildEnvironments(ctx, builder);
+			}
+		},
+		generateBundle: { handler(_options, bundle) {
+			const environment = this.environment;
+			debug("[main] Generating manifest and entry points for environment:", environment.name);
+			const isRegisteredService = Object.keys(ctx.services).includes(environment.name);
+			let entryFile;
+			for (const [_name, file] of Object.entries(bundle)) if (file.type === "chunk" && isRegisteredService && file.isEntry) if (entryFile === void 0) entryFile = file.fileName;
+			else this.warn(`Multiple entry points found for service "${environment.name}"`);
+			if (isRegisteredService) {
+				if (entryFile === void 0) this.error(`No entry point found for service "${this.environment.name}".`);
+				ctx._entryPoints[this.environment.name] = entryFile;
+			}
+		} },
+		configureServer: (server) => {
+			debug("[main] Configuring dev server");
+			return configureViteDevServer(ctx, server);
+		},
+		async hotUpdate({ server, modules, timestamp }) {
+			const env = this.environment;
+			if (ctx.pluginConfig.experimental?.vite.serverReload === false || env.config.consumer === "client") return;
+			const clientEnvs = Object.values(server.environments).filter((env$1) => env$1.config.consumer === "client");
+			let hasServerOnlyModule = false;
+			const invalidated = /* @__PURE__ */ new Set();
+			for (const mod of modules) if (mod.id && !clientEnvs.some((env$1) => env$1.moduleGraph.getModuleById(mod.id))) {
+				hasServerOnlyModule = true;
+				env.moduleGraph.invalidateModule(mod, invalidated, timestamp, false);
+			}
+			if (hasServerOnlyModule) {
+				env.hot.send({ type: "full-reload" });
+				server.ws.send({ type: "full-reload" });
+				return [];
+			}
+		}
+	};
+}
+function nitroPrepare(ctx) {
+	return {
+		name: "nitro:prepare",
+		sharedDuringBuild: true,
+		applyToEnvironment: (env) => env.name === "nitro",
+		buildApp: {
+			order: "pre",
+			async handler() {
+				debug("[prepare] Preparing output directory");
+				const nitro$1 = ctx.nitro;
+				await prepare(nitro$1);
+			}
+		}
+	};
+}
+function nitroService(ctx) {
+	return {
+		name: "nitro:service",
+		enforce: "pre",
+		sharedDuringBuild: true,
+		applyToEnvironment: (env) => env.name === "nitro",
+		resolveId: {
+			filter: { id: /^#nitro-vite-setup$/ },
+			async handler(id) {
+				if (id === "#nitro-vite-setup") return {
+					id,
+					moduleSideEffects: true
+				};
+			}
+		},
+		load: {
+			filter: { id: /^#nitro-vite-setup$/ },
+			async handler(id) {
+				if (id === "#nitro-vite-setup") return prodSetup(ctx);
+			}
+		}
+	};
+}
+function createContext(pluginConfig) {
+	return {
+		pluginConfig,
+		services: { ...pluginConfig.experimental?.vite?.services },
+		_entryPoints: {}
+	};
+}
+function useNitro(ctx) {
+	if (!ctx.nitro) throw new Error("Nitro instance is not initialized yet.");
+	return ctx.nitro;
+}
+async function setupNitroContext(ctx, configEnv, userConfig) {
+	const nitroConfig = {
+		dev: configEnv.command === "serve",
+		builder: "vite",
+		rootDir: userConfig.root,
+		...defu(ctx.pluginConfig, ctx.pluginConfig.config, userConfig.nitro)
+	};
+	nitroConfig.modules ??= [];
+	for (const plugin of flattenPlugins(userConfig.plugins || [])) if (plugin.nitro) nitroConfig.modules.push(plugin.nitro);
+	ctx.nitro = ctx.pluginConfig._nitro || await createNitro(nitroConfig);
+	if (!ctx.services?.ssr) if (userConfig.environments?.ssr === void 0) {
+		const ssrEntry = resolveModulePath("./entry-server", {
+			from: [
+				"app",
+				"src",
+				""
+			].flatMap((d) => [ctx.nitro.options.rootDir, ...ctx.nitro.options.scanDirs].map((s) => join$1(s, d) + "/")),
+			extensions: DEFAULT_EXTENSIONS,
+			try: true
+		});
+		if (ssrEntry) {
+			ctx.services.ssr = { entry: ssrEntry };
+			ctx.nitro.logger.info(`Using \`${prettyPath(ssrEntry)}\` as vite ssr entry.`);
+		}
+	} else {
+		let ssrEntry = getEntry(userConfig.environments.ssr.build?.rollupOptions?.input);
+		if (typeof ssrEntry === "string") {
+			ssrEntry = resolveModulePath(ssrEntry, {
+				from: [ctx.nitro.options.rootDir, ...ctx.nitro.options.scanDirs],
+				extensions: DEFAULT_EXTENSIONS,
+				suffixes: ["", "/index"],
+				try: true
+			}) || ssrEntry;
+			ctx.services.ssr = { entry: ssrEntry };
+		}
+	}
+	if (ctx.nitro.options.serverEntry && ctx.nitro.options.serverEntry.handler === ctx.services.ssr?.entry) {
+		ctx.nitro.logger.warn(`Nitro server entry and Vite SSR both set to ${prettyPath(ctx.services.ssr.entry)}. Use a separate SSR entry (e.g. \`src/server.ts\`).`);
+		ctx.nitro.options.serverEntry = false;
+	}
+	if (!ctx.nitro.options.renderer?.handler && !ctx.nitro.options.renderer?.template && ctx.services.ssr?.entry) {
+		ctx.nitro.options.renderer ??= {};
+		ctx.nitro.options.renderer.handler = resolve$1(runtimeDir, "internal/vite/ssr-renderer");
+		ctx.nitro.routing.sync();
+	}
+	const publicDistDir = ctx._publicDistDir = userConfig.build?.outDir || resolve$1(ctx.nitro.options.buildDir, "vite/public");
+	ctx.nitro.options.publicAssets.push({
+		dir: publicDistDir,
+		maxAge: 0,
+		baseURL: "/",
+		fallthrough: true
+	});
+	if (!ctx.nitro.options.dev) ctx.nitro.options.unenv.push({
+		meta: { name: "nitro-vite" },
+		polyfill: ["#nitro-vite-setup"]
+	});
+	await ctx.nitro.hooks.callHook("build:before", ctx.nitro);
+	ctx.rollupConfig = await getViteRollupConfig(ctx);
+	await ctx.nitro.hooks.callHook("rollup:before", ctx.nitro, ctx.rollupConfig.config);
+	if (ctx.nitro.options.dev) getEnvRunner(ctx);
+	ctx.nitro.fetch = (req) => getEnvRunner(ctx).fetch(req);
+	if (ctx.nitro.options.dev && !ctx.devApp) ctx.devApp = new NitroDevApp(ctx.nitro);
+	ctx.nitro.hooks.hook("close", async () => {
+		if (ctx._envRunner) await ctx._envRunner.close();
+	});
+}
+function getEntry(input) {
+	if (typeof input === "string") return input;
+	else if (Array.isArray(input) && input.length > 0) return input[0];
+	else if (input && "index" in input) return input.index;
+}
+function flattenPlugins(plugins$1) {
+	return plugins$1.flatMap((plugin) => Array.isArray(plugin) ? flattenPlugins(plugin) : [plugin]).filter((p) => p && !(p instanceof Promise));
+}
+
+//#endregion
+export { baseBuildConfig as a, libChunkName as i, NODE_MODULES_RE$1 as n, nitro, getChunkName as r, baseBuildPlugins as t };