nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-121649-98b56dfe

package/dist/_build/common.mjs

@@ -0,0 +1,763 @@
+import { s as __toESM } from "../_chunks/DXMHy5ca.mjs";
+import { T as resolve$1, _ as dirname$1, b as join$1, v as extname$1, w as relative$1 } from "../_libs/c12.mjs";
+import { i as unplugin } from "../_libs/unimport.mjs";
+import { t as glob } from "../_libs/tinyglobby.mjs";
+import { u as writeFile$1 } from "../_chunks/B5ooyfLk.mjs";
+import { t as src_default } from "../_libs/mime.mjs";
+import { i as genSafeVariableName, t as genImport } from "../_libs/knitwork.mjs";
+import { t as require_etag } from "../_libs/etag.mjs";
+import { t as replace } from "../_libs/plugin-replace.mjs";
+import { t as rollup } from "../_libs/unwasm.mjs";
+import { dirname } from "node:path";
+import { camelCase } from "scule";
+import { promises } from "node:fs";
+import { withTrailingSlash } from "ufo";
+import { mkdir, readFile, symlink, unlink } from "node:fs/promises";
+import { defu } from "defu";
+import { runtimeDependencies, runtimeDir } from "nitro/runtime/meta";
+import { builtinDrivers, normalizeKey } from "unstorage";
+import { hash } from "ohash";
+import { version } from "nitro/meta";
+import { defineEnv } from "unenv";
+import { connectors } from "db0";
+import { transform } from "esbuild";
+import { rollupNodeFileTrace } from "nf3";
+import { RENDER_CONTEXT_KEYS, compileTemplateToString, hasTemplateSyntax } from "rendu";
+
+//#region src/build/plugins/replace.ts
+const NO_REPLACE_RE = /ROLLUP_NO_REPLACE|\\0raw:/;
+function replace$1(options) {
+	const _plugin = replace(options);
+	return {
+		..._plugin,
+		renderChunk(code, chunk, options$1) {
+			if (!NO_REPLACE_RE.test(code)) return _plugin.renderChunk.call(this, code, chunk, options$1);
+		}
+	};
+}
+
+//#endregion
+//#region src/build/config.ts
+function baseBuildConfig(nitro) {
+	const buildServerDir = join$1(nitro.options.buildDir, "dist/server");
+	const presetsDir$1 = resolve$1(runtimeDir, "../presets");
+	const extensions = [
+		".ts",
+		".mjs",
+		".js",
+		".json",
+		".node",
+		".tsx",
+		".jsx"
+	];
+	const isNodeless = nitro.options.node === false;
+	let NODE_ENV = nitro.options.dev ? "development" : "production";
+	if (nitro.options.preset === "nitro-prerender") NODE_ENV = "prerender";
+	const buildEnvVars = {
+		NODE_ENV,
+		prerender: nitro.options.preset === "nitro-prerender",
+		server: true,
+		client: false,
+		dev: String(nitro.options.dev),
+		DEBUG: nitro.options.dev
+	};
+	const staticFlags = {
+		dev: nitro.options.dev,
+		preset: nitro.options.preset,
+		prerender: nitro.options.preset === "nitro-prerender",
+		server: true,
+		client: false,
+		nitro: true,
+		baseURL: nitro.options.baseURL,
+		"versions.nitro": "",
+		"versions?.nitro": "",
+		_asyncContext: nitro.options.experimental.asyncContext,
+		_websocket: nitro.options.experimental.websocket,
+		_tasks: nitro.options.experimental.tasks
+	};
+	const replaceDelimiters = [String.raw`\b`, String.raw`(?![\w.$])`];
+	const replacements = {
+		"typeof window": "\"undefined\"",
+		_import_meta_url_: "import.meta.url",
+		"globalThis.process.": "process.",
+		"process.env.RUNTIME_CONFIG": () => JSON.stringify(nitro.options.runtimeConfig, null, 2),
+		...Object.fromEntries(Object.entries(buildEnvVars).map(([key, val]) => [`process.env.${key}`, JSON.stringify(val)])),
+		...Object.fromEntries(Object.entries(buildEnvVars).map(([key, val]) => [`import.meta.env.${key}`, JSON.stringify(val)])),
+		...Object.fromEntries(Object.entries(staticFlags).map(([key, val]) => [`process.${key}`, JSON.stringify(val)])),
+		...Object.fromEntries(Object.entries(staticFlags).map(([key, val]) => [`import.meta.${key}`, JSON.stringify(val)])),
+		...nitro.options.replace
+	};
+	const { env } = defineEnv({
+		nodeCompat: isNodeless,
+		npmShims: true,
+		resolve: true,
+		presets: nitro.options.unenv,
+		overrides: { alias: nitro.options.alias }
+	});
+	return {
+		buildServerDir,
+		presetsDir: presetsDir$1,
+		extensions,
+		isNodeless,
+		buildEnvVars,
+		staticFlags,
+		replaceDelimiters,
+		replacements,
+		env,
+		aliases: resolveAliases({
+			"#internal/nitro": runtimeDir,
+			"nitro/runtime": runtimeDir,
+			"nitropack/runtime": runtimeDir,
+			...env.alias
+		})
+	};
+}
+function resolveAliases(_aliases) {
+	const aliases = Object.fromEntries(Object.entries(_aliases).sort(([a], [b]) => b.split("/").length - a.split("/").length || b.length - a.length));
+	for (const key in aliases) for (const alias in aliases) {
+		if (![
+			"~",
+			"@",
+			"#"
+		].includes(alias[0])) continue;
+		if (alias === "@" && !aliases[key].startsWith("@/")) continue;
+		if (aliases[key].startsWith(alias)) aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
+	}
+	return aliases;
+}
+
+//#endregion
+//#region src/build/plugins/virtual.ts
+const PREFIX = "\0virtual:";
+function virtual(modules, cache = {}) {
+	const _modules = /* @__PURE__ */ new Map();
+	for (const [id, mod] of Object.entries(modules)) {
+		cache[id] = mod;
+		_modules.set(id, mod);
+		_modules.set(resolve$1(id), mod);
+	}
+	return {
+		name: "virtual",
+		resolveId(id, importer) {
+			if (id in modules) return PREFIX + id;
+			if (importer) {
+				const resolved = resolve$1(dirname$1(importer.startsWith(PREFIX) ? importer.slice(9) : importer), id);
+				if (_modules.has(resolved)) return PREFIX + resolved;
+			}
+			return null;
+		},
+		async load(id) {
+			if (!id.startsWith(PREFIX)) return null;
+			const idNoPrefix = id.slice(9);
+			if (!_modules.has(idNoPrefix)) return null;
+			let m = _modules.get(idNoPrefix);
+			if (typeof m === "function") m = await m();
+			if (!m) return null;
+			cache[id.replace(PREFIX, "")] = m;
+			return {
+				code: m,
+				map: null
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/build/plugins/database.ts
+function database(nitro) {
+	if (!nitro.options.experimental.database) return virtual({ "#nitro-internal-virtual/database": () => {
+		return `export const connectionConfigs = {};`;
+	} }, nitro.vfs);
+	const dbConfigs = nitro.options.dev && nitro.options.devDatabase || nitro.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 virtual({ "#nitro-internal-virtual/database": () => {
+		return `
+${connectorsNames.map((name) => `import ${camelCase(name)}Connector from "${connectors[name]}";`).join("\n")}
+
+export const connectionConfigs = {
+  ${Object.entries(dbConfigs || {}).map(([name, { connector, options }]) => `${name}: {
+          connector: ${camelCase(connector)}Connector,
+          options: ${JSON.stringify(options)}
+        }`).join(",\n")}
+};
+        `;
+	} }, nitro.vfs);
+}
+
+//#endregion
+//#region src/build/plugins/routing.ts
+const RuntimeRouteRules = [
+	"headers",
+	"redirect",
+	"proxy",
+	"cache"
+];
+function routing(nitro) {
+	return virtual({
+		"#nitro-internal-virtual/routing": () => {
+			const allHandlers = uniqueBy([
+				...Object.values(nitro.routing.routes.routes).map((h) => h.data),
+				...Object.values(nitro.routing.routedMiddleware.routes).map((h) => h.data),
+				...nitro.routing.globalMiddleware
+			], "_importHash");
+			const h3Imports = [
+				allHandlers.some((h) => !h.lazy) && "toEventHandler",
+				nitro.options.serverEntry && "toMiddleware",
+				allHandlers.some((h) => h.lazy) && "defineLazyEventHandler"
+			].filter(Boolean);
+			return `
+import * as __routeRules__ from "nitro/runtime/internal/route-rules";
+${nitro.options.serverEntry ? `import __serverEntry__ from ${JSON.stringify(nitro.options.serverEntry)};` : ""}
+import {${h3Imports.join(", ")}} from "h3";
+
+export const findRouteRules = ${nitro.routing.routeRules.compileToString({
+				serialize: serializeRouteRule,
+				matchAll: true
+			})}
+
+${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} = defineLazyEventHandler(() => import("${h.handler}"));`).join("\n")}
+
+export const findRoute = ${nitro.routing.routes.compileToString({ serialize: serializeHandler })}
+
+export const findRoutedMiddleware = ${nitro.routing.routedMiddleware.compileToString({
+				serialize: serializeHandler,
+				matchAll: true
+			})};
+
+export const globalMiddleware = [
+  ${nitro.routing.globalMiddleware.map((h) => h.lazy ? h._importHash : `toEventHandler(${h._importHash})`).join(",")}
+  ${nitro.options.serverEntry ? `,toMiddleware(__serverEntry__)` : ""}
+].filter(Boolean);
+  `;
+		},
+		"#nitro-internal-virtual/routing-meta": () => {
+			const routeHandlers = uniqueBy(Object.values(nitro.routing.routes.routes).map((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();
+		}
+	}, nitro.vfs);
+}
+function uniqueBy(arr, key) {
+	return [...new Map(arr.map((item) => [item[key], item])).values()];
+}
+function serializeHandler(h) {
+	return `{${[
+		`route:${JSON.stringify(h.route)}`,
+		h.method && `method:${JSON.stringify(h.method)}`,
+		h.meta && `meta:${JSON.stringify(h.meta)}`,
+		`handler:${h.lazy ? h._importHash : `toEventHandler(${h._importHash})`}`
+	].filter(Boolean).join(",")}}`;
+}
+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/plugins/route-meta.ts
+const virtualPrefix = "\0nitro-handler-meta:";
+const esbuildLoaders = {
+	".ts": "ts",
+	".js": "js",
+	".tsx": "tsx",
+	".jsx": "jsx"
+};
+function routeMeta(nitro) {
+	return {
+		name: "nitro:route-meta",
+		async resolveId(id, importer, resolveOpts) {
+			if (id.startsWith("\0")) return;
+			if (id.endsWith(`?meta`)) {
+				const resolved = await this.resolve(id.replace(`?meta`, ``), importer, resolveOpts);
+				if (!resolved) return;
+				return virtualPrefix + resolved.id;
+			}
+		},
+		load(id) {
+			if (id.startsWith(virtualPrefix)) return readFile(id.slice(20), { encoding: "utf8" });
+		},
+		async transform(code, id) {
+			if (!id.startsWith(virtualPrefix)) return;
+			let meta = null;
+			try {
+				const jsCode = await transform(code, { loader: esbuildLoaders[extname$1(id)] }).then((r) => r.code);
+				const ast = this.parse(jsCode);
+				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.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(Boolean);
+		case "Literal": return node.value;
+	}
+}
+
+//#endregion
+//#region src/build/plugins/server-main.ts
+function serverMain(nitro) {
+	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/public-assets.ts
+var import_etag$1 = /* @__PURE__ */ __toESM(require_etag(), 1);
+const readAssetHandler = {
+	true: "node",
+	node: "node",
+	false: "null",
+	deno: "deno",
+	inline: "inline"
+};
+function publicAssets(nitro) {
+	return virtual({
+		"#nitro-internal-virtual/public-assets-data": async () => {
+			const assets = {};
+			const files = await glob("**", {
+				cwd: nitro.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.options.output.publicDir, id);
+				const assetData = await promises.readFile(fullPath);
+				const etag = (0, import_etag$1.default)(assetData);
+				const stat$1 = await promises.stat(fullPath);
+				const assetId = "/" + decodeURIComponent(id);
+				let encoding;
+				if (id.endsWith(".gz")) encoding = "gzip";
+				else if (id.endsWith(".br")) encoding = "br";
+				assets[assetId] = {
+					type: nitro._prerenderMeta?.[assetId]?.contentType || mimeType,
+					encoding,
+					etag,
+					mtime: stat$1.mtime.toJSON(),
+					size: stat$1.size,
+					path: relative$1(nitro.options.output.serverDir, fullPath),
+					data: nitro.options.serveStatic === "inline" ? assetData.toString("base64") : void 0
+				};
+			}
+			return `export default ${JSON.stringify(assets, null, 2)};`;
+		},
+		"#nitro-internal-virtual/public-assets-node": () => {
+			return `
+import { promises as fsp } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { resolve, dirname } from 'node:path'
+import assets from '#nitro-internal-virtual/public-assets-data'
+export function readAsset (id) {
+  const serverDir = dirname(fileURLToPath(globalThis.__nitro_main__))
+  return fsp.readFile(resolve(serverDir, assets[id].path))
+}`;
+		},
+		"#nitro-internal-virtual/public-assets-deno": () => {
+			return `
+import assets from '#nitro-internal-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);
+}`;
+		},
+		"#nitro-internal-virtual/public-assets-null": () => {
+			return `
+    export function readAsset (id) {
+        return Promise.resolve(null);
+    }`;
+		},
+		"#nitro-internal-virtual/public-assets-inline": () => {
+			return `
+  import assets from '#nitro-internal-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
+}`;
+		},
+		"#nitro-internal-virtual/public-assets": () => {
+			const publicAssetBases = Object.fromEntries(nitro.options.publicAssets.filter((dir) => !dir.fallthrough && dir.baseURL !== "/").map((dir) => [withTrailingSlash(dir.baseURL), { maxAge: dir.maxAge }]));
+			return `
+import assets from '#nitro-internal-virtual/public-assets-data'
+export { readAsset } from "${`#nitro-internal-virtual/public-assets-${readAssetHandler[nitro.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]
+}
+`;
+		}
+	}, nitro.vfs);
+}
+
+//#endregion
+//#region src/build/plugins/server-assets.ts
+var import_etag = /* @__PURE__ */ __toESM(require_etag(), 1);
+function serverAssets(nitro) {
+	if (nitro.options.dev || nitro.options.preset === "nitro-prerender") return virtual({ "#nitro-internal-virtual/server-assets": getAssetsDev(nitro) }, nitro.vfs);
+	return virtual({ "#nitro-internal-virtual/server-assets": async () => {
+		const assets = {};
+		for (const asset of nitro.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 getAssetProd(assets);
+	} }, nitro.vfs);
+}
+function getAssetsDev(nitro) {
+	return `
+import { createStorage } from 'unstorage'
+import fsDriver from 'unstorage/drivers/fs'
+
+const serverAssets = ${JSON.stringify(nitro.options.serverAssets)}
+
+export const assets = createStorage()
+
+for (const asset of serverAssets) {
+  assets.mount(asset.baseName, fsDriver({ base: asset.dir, ignore: (asset?.ignore || []) }))
+}`;
+}
+function getAssetProd(assets) {
+	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/plugins/storage.ts
+function storage(nitro) {
+	const mounts = [];
+	const isDevOrPrerender = nitro.options.dev || nitro.options.preset === "nitro-prerender";
+	const storageMounts = isDevOrPrerender ? {
+		...nitro.options.storage,
+		...nitro.options.devStorage
+	} : nitro.options.storage;
+	for (const path$1 in storageMounts) {
+		const mount = storageMounts[path$1];
+		mounts.push({
+			path: path$1,
+			driver: builtinDrivers[mount.driver] || mount.driver,
+			opts: mount
+		});
+	}
+	const driverImports = [...new Set(mounts.map((m) => m.driver))];
+	const bundledStorageCode = `
+import { prefixStorage } from 'unstorage'
+import overlay from 'unstorage/drivers/overlay'
+import memory from 'unstorage/drivers/memory'
+
+const bundledStorage = ${JSON.stringify(nitro.options.bundledStorage)}
+for (const base of bundledStorage) {
+  storage.mount(base, overlay({
+    layers: [
+      memory(),
+      // TODO
+      // prefixStorage(storage, base),
+      prefixStorage(storage, 'assets:nitro:bundled:' + base)
+    ]
+  }))
+}`;
+	return virtual({ "#nitro-internal-virtual/storage": `
+import { createStorage } from 'unstorage'
+import { assets } from '#nitro-internal-virtual/server-assets'
+
+${driverImports.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")}
+
+  ${!isDevOrPrerender && nitro.options.bundledStorage.length > 0 ? bundledStorageCode : ""}
+  return storage
+}
+` }, nitro.vfs);
+}
+
+//#endregion
+//#region src/build/plugins/error-handler.ts
+function errorHandler(nitro) {
+	return virtual({ "#nitro-internal-virtual/error-handler": () => {
+		const errorHandlers = Array.isArray(nitro.options.errorHandler) ? nitro.options.errorHandler : [nitro.options.errorHandler];
+		const builtinHandler = join$1(runtimeDir, `internal/error/${nitro.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
+}
+`;
+	} }, nitro.vfs);
+}
+
+//#endregion
+//#region src/build/plugins/renderer-template.ts
+function rendererTemplate(nitro) {
+	return virtual({ "#nitro-internal-virtual/renderer-template": async () => {
+		if (typeof nitro.options.renderer?.template !== "string") return `export const rendererTemplate = () => '<!-- renderer.template is not set -->'; export const rendererTemplateFile = undefined;`;
+		if (nitro.options.dev) return `import { readFile } from 'node:fs/promises';export const rendererTemplate = () => readFile(${JSON.stringify(nitro.options.renderer?.template)}, "utf8"); export const rendererTemplateFile = ${JSON.stringify(nitro.options.renderer?.template)};`;
+		else {
+			const html = await readFile(nitro.options.renderer?.template, "utf8");
+			if (hasTemplateSyntax(html)) return `
+            import { renderToResponse } from 'rendu'
+            const template = ${compileTemplateToString(html, { contextKeys: [...RENDER_CONTEXT_KEYS] })};
+            export const rendererTemplate = (request) => renderToResponse(template, { request })
+            `;
+			else return `
+              import { HTTPResponse } from "h3";
+              export const rendererTemplate = () => new HTTPResponse(${JSON.stringify(html)}, { headers: { "content-type": "text/html; charset=utf-8" } });
+            `;
+		}
+	} }, nitro.vfs);
+}
+
+//#endregion
+//#region src/build/plugins/feature-flags.ts
+function featureFlags(nitro) {
+	return virtual({ "#nitro-internal-virtual/feature-flags": () => {
+		const featureFlags$1 = {
+			hasRoutes: nitro.routing.routes.hasRoutes(),
+			hasRouteRules: nitro.routing.routeRules.hasRoutes(),
+			hasRoutedMiddleware: nitro.routing.routedMiddleware.hasRoutes(),
+			hasGlobalMiddleware: nitro.routing.globalMiddleware.length > 0 || !!nitro.options.serverEntry,
+			hasPlugins: nitro.options.plugins.length > 0,
+			hasHooks: nitro.options.features?.runtimeHooks ?? nitro.options.plugins.length > 0
+		};
+		return Object.entries(featureFlags$1).map(([key, value]) => `export const ${key} = ${Boolean(value)};`).join("\n");
+	} }, nitro.vfs);
+}
+
+//#endregion
+//#region src/build/plugins/resolve.ts
+const subpathMap = {
+	"nitro/h3": "h3",
+	"nitro/deps/h3": "h3",
+	"nitro/deps/ofetch": "ofetch"
+};
+function nitroResolveIds() {
+	return {
+		name: "nitro:resolve-ids",
+		resolveId: {
+			order: "pre",
+			handler(id, importer, rOpts) {
+				if (importer && importer.startsWith("\0virtual:#nitro-internal-virtual")) return this.resolve(id, runtimeDir, { skipSelf: true });
+				const mappedId = subpathMap[id];
+				if (mappedId) return this.resolve(mappedId, runtimeDir, { skipSelf: true });
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/build/plugins.ts
+function baseBuildPlugins(nitro, base) {
+	const plugins = [];
+	if (nitro.options.imports) plugins.push(unplugin.rollup(nitro.options.imports));
+	if (nitro.options.experimental.wasm) plugins.push(rollup(nitro.options.wasm || {}));
+	plugins.push(serverMain(nitro));
+	const nitroPlugins = [...new Set(nitro.options.plugins)];
+	plugins.push(virtual({ "#nitro-internal-virtual/plugins": `
+  ${nitroPlugins.map((plugin) => `import _${hash(plugin).replace(/-/g, "")} from '${plugin}';`).join("\n")}
+
+  export const plugins = [
+    ${nitroPlugins.map((plugin) => `_${hash(plugin).replace(/-/g, "")}`).join(",\n")}
+  ]
+      ` }, nitro.vfs));
+	plugins.push(featureFlags(nitro));
+	plugins.push(nitroResolveIds());
+	plugins.push(serverAssets(nitro));
+	plugins.push(publicAssets(nitro));
+	plugins.push(storage(nitro));
+	plugins.push(database(nitro));
+	plugins.push(routing(nitro));
+	if (nitro.options.experimental.openAPI) plugins.push(routeMeta(nitro));
+	plugins.push(errorHandler(nitro));
+	plugins.push(virtual({ "#nitro-internal-pollyfills": base.env.polyfill.map((p) => `import '${p}';`).join("\n") || `/* No polyfills */` }, nitro.vfs));
+	plugins.push(virtual(nitro.options.virtual, nitro.vfs));
+	if (nitro.options.renderer?.template) plugins.push(rendererTemplate(nitro));
+	if (!nitro.options.noExternals) plugins.push(rollupNodeFileTrace(defu(nitro.options.externals, {
+		outDir: nitro.options.output.serverDir,
+		moduleDirectories: nitro.options.nodeModulesDirs,
+		external: [...nitro.options.dev ? [nitro.options.buildDir] : [], ...nitro.options.nodeModulesDirs],
+		inline: [
+			"#",
+			"~",
+			"@/",
+			"~~",
+			"@@/",
+			"virtual:",
+			"nitro/runtime",
+			dirname$1(nitro.options.entry),
+			...nitro.options.experimental.wasm ? [(id) => id?.endsWith(".wasm")] : [],
+			runtimeDir,
+			nitro.options.srcDir,
+			...nitro.options.handlers.map((m) => m.handler).filter((i) => typeof i === "string"),
+			...nitro.options.dev || nitro.options.preset === "nitro-prerender" || nitro.options.experimental.bundleRuntimeDependencies === false ? [] : runtimeDependencies
+		],
+		traceOptions: {
+			base: "/",
+			processCwd: nitro.options.rootDir,
+			exportsOnly: true
+		},
+		traceAlias: {
+			"h3-nightly": "h3",
+			...nitro.options.externals?.traceAlias
+		},
+		exportConditions: nitro.options.exportConditions,
+		writePackageJson: true
+	})));
+	return plugins;
+}
+
+//#endregion
+//#region src/presets/_types.gen.ts
+const presetsWithConfig = [
+	"awsAmplify",
+	"awsLambda",
+	"azure",
+	"cloudflare",
+	"firebase",
+	"netlify",
+	"vercel"
+];
+
+//#endregion
+//#region src/build/info.ts
+async function writeBuildInfo(nitro) {
+	const buildInfoPath = resolve$1(nitro.options.output.dir, "nitro.json");
+	const buildInfo = {
+		date: (/* @__PURE__ */ new Date()).toJSON(),
+		preset: nitro.options.preset,
+		framework: nitro.options.framework,
+		versions: { nitro: version },
+		commands: {
+			preview: nitro.options.commands.preview,
+			deploy: nitro.options.commands.deploy
+		},
+		config: { ...Object.fromEntries(presetsWithConfig.map((key) => [key, nitro.options[key]])) }
+	};
+	await writeFile$1(buildInfoPath, JSON.stringify(buildInfo, null, 2), true);
+	const lastBuild = resolve$1(nitro.options.rootDir, "node_modules/.nitro/last-build");
+	await mkdir(dirname(lastBuild), { recursive: true });
+	await unlink(lastBuild).catch(() => {});
+	await symlink(nitro.options.output.dir, lastBuild).catch(console.warn);
+	return buildInfo;
+}
+
+//#endregion
+export { replace$1 as i, baseBuildPlugins as n, baseBuildConfig as r, writeBuildInfo as t };