nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-121649-98b56dfe

package/dist/_build/vite.plugin.mjs

@@ -0,0 +1,747 @@
+import { T as resolve$1, _ as dirname$1, b as join$1, f as resolveModulePath, g as basename$1, n as debounce, w as relative$1, x as normalize$1, y as isAbsolute$1 } from "../_libs/c12.mjs";
+import { f as sanitizeFilePath } from "../_libs/local-pkg.mjs";
+import { t as formatCompatibilityDate } from "../_libs/compatx.mjs";
+import { n as a, t as T } from "../_libs/std-env.mjs";
+import { a as createNitro, n as prepare, r as copyPublicAssets } from "../_chunks/B-7HiF0V.mjs";
+import { c as prettyPath, o as scanHandlers } from "../_chunks/B5ooyfLk.mjs";
+import { t as createProxyServer } from "../_libs/httpxy.mjs";
+import { i as NodeDevWorker, r as NitroDevApp } from "../_dev.mjs";
+import { i as watch$1 } from "../_libs/chokidar.mjs";
+import { t as alias } from "../_libs/plugin-alias.mjs";
+import { t as inject } from "../_libs/plugin-inject.mjs";
+import { i as replace, n as baseBuildPlugins, r as baseBuildConfig, t as writeBuildInfo } from "./common.mjs";
+import { t as assetsPlugin } from "../_libs/vite-plugin-fullstack.mjs";
+import consola$1 from "consola";
+import { join, resolve } from "node:path";
+import { existsSync, watch } from "node:fs";
+import { mkdir, readFile, readlink, rm, writeFile } from "node:fs/promises";
+import { defu } from "defu";
+import { runtimeDependencies, runtimeDir } from "nitro/runtime/meta";
+import { colors } from "consola/utils";
+import { NodeRequest, sendNodeResponse } from "srvx/node";
+import { DevEnvironment } from "vite";
+import { getRandomPort } from "get-port-please";
+import { spawn } from "node:child_process";
+
+//#region src/build/vite/rollup.ts
+/**
+* Removed from base rollup config:
+*  - nodeResolve
+*  - commonjs
+*  - esbuild
+*  - sourcemapMininify
+*  - json
+*  - raw
+*
+* TODO: Reuse with rollup:
+* - chunkFileNames
+* - moduleSideEffects
+*/
+const getViteRollupConfig = (ctx) => {
+	const nitro$1 = ctx.nitro;
+	const base = baseBuildConfig(nitro$1);
+	const chunkNamePrefixes = [
+		[nitro$1.options.buildDir, "build"],
+		[base.buildServerDir, "app"],
+		[runtimeDir, "nitro"],
+		[base.presetsDir, "nitro"],
+		["\0nitro-wasm:", "wasm"],
+		["\0", "virtual"]
+	];
+	function getChunkGroup(id) {
+		if (id.startsWith(runtimeDir) || id.startsWith(base.presetsDir)) return "nitro";
+	}
+	let config = {
+		input: nitro$1.options.entry,
+		external: [...base.env.external],
+		plugins: [
+			ctx.pluginConfig.experimental?.virtualBundle && virtualBundlePlugin(ctx._serviceBundles),
+			...baseBuildPlugins(nitro$1, base),
+			alias({ entries: base.aliases }),
+			replace({
+				delimiters: base.replaceDelimiters,
+				preventAssignment: true,
+				values: base.replacements
+			}),
+			inject(base.env.inject)
+		].filter(Boolean),
+		treeshake: { moduleSideEffects(id) {
+			const normalizedId = normalize$1(id);
+			const idWithoutNodeModules = normalizedId.split("node_modules/").pop();
+			if (!idWithoutNodeModules) return false;
+			if (normalizedId.startsWith(runtimeDir) || idWithoutNodeModules.startsWith(runtimeDir)) return true;
+			return nitro$1.options.moduleSideEffects.some((m) => normalizedId.startsWith(m) || idWithoutNodeModules.startsWith(m));
+		} },
+		output: {
+			dir: nitro$1.options.output.serverDir,
+			entryFileNames: "index.mjs",
+			chunkFileNames(chunk) {
+				const id = normalize$1(chunk.moduleIds.at(-1) || "");
+				for (const [dir, name] of chunkNamePrefixes) if (id.startsWith(dir)) return `chunks/${name}/[name].mjs`;
+				const routeHandler = nitro$1.options.handlers.find((h) => id.startsWith(h.handler)) || nitro$1.scannedHandlers.find((h) => id.startsWith(h.handler));
+				if (routeHandler?.route) return `chunks/routes/${routeHandler.route.replace(/:([^/]+)/g, "_$1").replace(/\/[^/]+$/g, "") || "/"}/[name].mjs`.replace(/\/+/g, "/");
+				if (Object.entries(nitro$1.options.tasks).find(([_, task]) => task.handler === id)) return `chunks/tasks/[name].mjs`;
+				return `chunks/_/[name].mjs`;
+			},
+			manualChunks(id) {
+				return getChunkGroup(id);
+			},
+			inlineDynamicImports: nitro$1.options.inlineDynamicImports,
+			format: "esm",
+			exports: "auto",
+			intro: "",
+			outro: "",
+			generatedCode: { constBindings: true },
+			sanitizeFileName: sanitizeFilePath,
+			sourcemapExcludeSources: true,
+			sourcemapIgnoreList(relativePath) {
+				return relativePath.includes("node_modules");
+			}
+		}
+	};
+	config = defu(nitro$1.options.rollupConfig, config);
+	if (config.output.inlineDynamicImports) delete config.output.manualChunks;
+	return {
+		config,
+		base
+	};
+};
+function virtualBundlePlugin(bundles) {
+	let _modules = null;
+	const getModules = () => {
+		if (_modules) return _modules;
+		_modules = /* @__PURE__ */ new Map();
+		for (const bundle of Object.values(bundles)) for (const [fileName, content] of Object.entries(bundle)) if (content.type === "chunk") {
+			const virtualModule = {
+				code: content.code,
+				map: null
+			};
+			const maybeMap = bundle[`${fileName}.map`];
+			if (maybeMap && maybeMap.type === "asset") virtualModule.map = maybeMap.source;
+			_modules.set(fileName, virtualModule);
+			_modules.set(resolve$1(fileName), virtualModule);
+		}
+		return _modules;
+	};
+	return {
+		name: "virtual-bundle",
+		resolveId(id, importer) {
+			const modules = getModules();
+			if (modules.has(id)) return resolve$1(id);
+			if (importer) {
+				const resolved = resolve$1(dirname$1(importer), id);
+				if (modules.has(resolved)) return resolved;
+			}
+			return null;
+		},
+		load(id) {
+			const m = getModules().get(id);
+			if (!m) return null;
+			return m;
+		}
+	};
+}
+
+//#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-->", `{{{ fetch($REQUEST, { viteEnv: "ssr" }) }}}`));
+			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);
+	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) {
+	const services = ctx.pluginConfig.services || {};
+	const serviceEntries = Object.keys(services).map((name) => {
+		let entry;
+		if (ctx.pluginConfig.experimental?.virtualBundle) entry = ctx._entryPoints[name];
+		else entry = resolve$1(ctx.nitro.options.buildDir, "vite/services", name, ctx._entryPoints[name]);
+		return [name, entry];
+	});
+	return `
+import { setupVite } from "${resolve$1(runtimeDir, "internal/vite/prod-setup.mjs")}";
+
+const manifest = ${JSON.stringify(ctx._manifest || {})};
+
+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 = {
+${serviceEntries.map(([name, entry]) => `[${JSON.stringify(name)}]: lazyService(() => import(${JSON.stringify(entry)}))`).join(",\n")}
+};
+
+setupVite({ manifest, 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);
+	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$1) => {
+		if (watchReloadEvents.has(event)) reload();
+	});
+	const srcDirWatcher = watch(nitro$1.options.srcDir, { persistent: false }, (_event, filename) => {
+		if (filename && /^server\.[mc]?[jt]sx?$/.test(filename)) reload();
+	});
+	nitro$1.hooks.hook("close", () => {
+		scanDirsWatcher.close();
+		srcDirWatcher.close();
+	});
+	const hostIPC = { async transformHTML(html) {
+		return server.transformIndexHtml("/", html).then((r) => r.replace("<!--ssr-outlet-->", `{{{ fetch($REQUEST, { viteEnv: "ssr" }) }}}`));
+	} };
+	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 (/^\/@(?:vite|fs|id)\//.test(nodeReq.url) || nodeReq._nitroHandled) return next();
+		nodeReq._nitroHandled = true;
+		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;
+		if (envRes.status !== 404) return await sendNodeResponse(nodeRes, envRes);
+		return next();
+	};
+	server.middlewares.use(function nitroDevMiddlewarePre(req, res, next) {
+		const fetchDest = req.headers["sec-fetch-dest"];
+		if (fetchDest) res.setHeader("vary", "sec-fetch-dest");
+		if (!((req.url || "").match(/\.([a-z0-9]+)(?:[?#]|$)/i)?.[1] || "") && (!fetchDest || /^(document|iframe|frame|empty)$/.test(fetchDest))) nitroDevMiddleware(req, res, next);
+		else next();
+	});
+	return () => {
+		server.middlewares.use(nitroDevMiddleware);
+	};
+}
+
+//#endregion
+//#region src/build/vite/env.ts
+function createDevWorker(ctx) {
+	return new NodeDevWorker({
+		name: "nitro-vite",
+		entry: resolve(runtimeDir, "internal/vite/dev-worker.mjs"),
+		hooks: {},
+		data: {
+			server: true,
+			globals: { __NITRO_RUNTIME_CONFIG__: ctx.nitro.options.runtimeConfig }
+		}
+	});
+}
+function createNitroEnvironment(ctx) {
+	return {
+		consumer: "server",
+		build: {
+			rollupOptions: ctx.rollupConfig.config,
+			minify: ctx.nitro.options.minify,
+			emptyOutDir: false,
+			commonjsOptions: {
+				strictRequires: "auto",
+				esmExternals: (id) => !id.startsWith("unenv/"),
+				requireReturnsDefault: "auto",
+				...ctx.nitro.options.commonJS
+			}
+		},
+		resolve: {
+			noExternal: ctx.nitro.options.dev ? new RegExp(runtimeDependencies.join("|")) : true,
+			conditions: ctx.nitro.options.exportConditions,
+			externalConditions: ctx.nitro.options.exportConditions
+		},
+		dev: { createEnvironment: (envName, envConfig) => createFetchableDevEnvironment(envName, envConfig, ctx.devWorker, resolve(runtimeDir, "internal/vite/dev-entry.mjs")) }
+	};
+}
+function createServiceEnvironment(ctx, name, serviceConfig) {
+	return {
+		consumer: "server",
+		build: {
+			rollupOptions: { input: serviceConfig.entry },
+			minify: ctx.nitro.options.minify,
+			outDir: join(ctx.nitro.options.buildDir, "vite", "services", name),
+			emptyOutDir: true
+		},
+		resolve: {
+			conditions: ctx.nitro.options.exportConditions,
+			externalConditions: ctx.nitro.options.exportConditions
+		},
+		dev: { createEnvironment: (envName, envConfig) => createFetchableDevEnvironment(envName, envConfig, ctx.devWorker, tryResolve(serviceConfig.entry)) }
+	};
+}
+function createServiceEnvironments(ctx) {
+	return Object.fromEntries(Object.entries(ctx.pluginConfig.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 buildInfoPath = resolve$1(server.config.root, "node_modules/.nitro/last-build", "nitro.json");
+			if (!existsSync(buildInfoPath)) {
+				console.warn(`[nitro] No build found. Please build your project before previewing.`);
+				return;
+			}
+			const realBuildDir = await readlink("node_modules/.nitro/last-build");
+			const buildInfo = JSON.parse(await readFile(buildInfoPath, "utf8"));
+			const info = [
+				["Build Directory:", prettyPath(realBuildDir)],
+				["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("[nitro] No preview command found for this preset..");
+				return;
+			}
+			const randomPort = await getRandomPort();
+			consola$1.info(`Spawning preview server...`);
+			const [command, ...args] = buildInfo.commands.preview.split(" ");
+			let child;
+			consola$1.info(buildInfo.commands?.preview);
+			child = spawn(command, args, {
+				stdio: "inherit",
+				cwd: realBuildDir,
+				env: {
+					...process.env,
+					PORT: String(randomPort)
+				}
+			});
+			process.on("exit", () => {
+				child?.kill();
+				child = void 0;
+			});
+			child.on("exit", (code) => {
+				if (code && code !== 0) consola$1.error(`[nitro] Preview server exited with code ${code}`);
+			});
+			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.`);
+			});
+		}
+	};
+}
+
+//#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?.assetsImport !== false && assetsPlugin({ experimental: { clientBuildFallback: false } })
+	];
+}
+function nitroInit(ctx) {
+	return {
+		name: "nitro:init",
+		sharedDuringBuild: true,
+		apply: (_config, configEnv) => !configEnv.isPreview,
+		async config(config, configEnv) {
+			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;
+			} else if (ctx.pluginConfig.experimental?.virtualBundle && name in (ctx.pluginConfig.services || {})) {
+				debug("[env]  Configuring service environment for virtual:", name);
+				config.build ??= {};
+				config.build.write = config.build.write ?? false;
+			}
+		}
+	};
+}
+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
+				}
+			};
+		},
+		configResolved(config) {
+			if (config.command === "build") {
+				debug("[main] Inferring caching routes");
+				for (const env of Object.values(config.environments)) if (env.consumer === "client") {
+					const rule = ctx.nitro.options.routeRules[`/${env.build.assetsDir}/**`] ??= {};
+					if (!rule.headers?.["cache-control"]) rule.headers = {
+						...rule.headers,
+						"cache-control": `public, max-age=31536000, immutable`
+					};
+				}
+			}
+			debug("[main] Syncing nitro routes");
+			ctx.nitro.routing.sync();
+		},
+		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 { root } = environment.config;
+			const services = ctx.pluginConfig.services || {};
+			const isRegisteredService = Object.keys(services).includes(environment.name);
+			let entryFile;
+			for (const [_name, file] of Object.entries(bundle)) if (file.type === "chunk") {
+				if (isRegisteredService && file.isEntry) if (entryFile === void 0) entryFile = file.fileName;
+				else this.warn(`Multiple entry points found for service "${environment.name}"`);
+				const filteredModuleIds = file.moduleIds.filter((id) => id.startsWith(root));
+				for (const id of filteredModuleIds) {
+					const originalFile = relative$1(root, id);
+					ctx._manifest[originalFile] = { file: file.fileName };
+				}
+			}
+			if (isRegisteredService) {
+				if (entryFile === void 0) this.error(`No entry point found for service "${this.environment.name}".`);
+				ctx._entryPoints[this.environment.name] = entryFile;
+				ctx._serviceBundles[this.environment.name] = bundle;
+			}
+		} },
+		configureServer: (server) => {
+			debug("[main] Configuring dev server");
+			return configureViteDevServer(ctx, server);
+		}
+	};
+}
+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: { async handler(id) {
+			if (id === "#nitro-vite-setup") return {
+				id,
+				moduleSideEffects: true
+			};
+			if (id === "#nitro-vite-services") return id;
+		} },
+		load: { async handler(id) {
+			if (id === "#nitro-vite-setup") return prodSetup(ctx);
+		} }
+	};
+}
+function createContext(pluginConfig) {
+	return {
+		pluginConfig,
+		_entryPoints: {},
+		_manifest: {},
+		_serviceBundles: {}
+	};
+}
+function useNitro(ctx) {
+	if (!ctx.nitro) throw new Error("Nitro instance is not initialized yet.");
+	return ctx.nitro;
+}
+async function setupNitroContext(ctx, configEnv, userConfig) {
+	ctx.nitro = ctx.pluginConfig._nitro || await createNitro({
+		dev: configEnv.mode === "development",
+		rootDir: userConfig.root,
+		...defu(ctx.pluginConfig.config, userConfig.nitro)
+	});
+	if (!ctx.pluginConfig.services?.ssr) {
+		ctx.pluginConfig.services ??= {};
+		if (userConfig.environments?.ssr === void 0) {
+			const ssrEntry = resolveModulePath("./entry-server", {
+				from: [
+					"",
+					"app",
+					"src"
+				].flatMap((d) => ctx.nitro.options.scanDirs.map((s) => join$1(s, d) + "/")),
+				extensions: DEFAULT_EXTENSIONS,
+				try: true
+			});
+			if (ssrEntry) {
+				ctx.pluginConfig.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.scanDirs,
+					extensions: DEFAULT_EXTENSIONS,
+					suffixes: ["", "/index"],
+					try: true
+				}) || ssrEntry;
+				ctx.pluginConfig.services.ssr = { entry: ssrEntry };
+			} else throw new TypeError(`Invalid input type for SSR entry point.`);
+		}
+	}
+	if (!ctx.nitro.options.renderer?.entry && !ctx.nitro.options.renderer?.template && ctx.pluginConfig.services.ssr?.entry) {
+		ctx.nitro.options.renderer ??= {};
+		ctx.nitro.options.renderer.entry = resolve$1(runtimeDir, "internal/vite/ssr-renderer");
+	}
+	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 && !ctx.devWorker) ctx.devWorker = createDevWorker(ctx);
+	if (ctx.nitro.options.dev && !ctx.devApp) ctx.devApp = new NitroDevApp(ctx.nitro);
+}
+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;
+}
+
+//#endregion
+export { nitro as t };