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

package/dist/_build/rolldown.mjs

@@ -0,0 +1,216 @@
+import { b as join, n as debounce, w as relative, x as normalize } from "../_libs/c12.mjs";
+import "../_libs/gen-mapping.mjs";
+import "../_libs/magic-string.mjs";
+import "../_libs/acorn.mjs";
+import "../_libs/confbox.mjs";
+import { f as sanitizeFilePath } from "../_libs/local-pkg.mjs";
+import "../_libs/js-tokens.mjs";
+import "../_libs/strip-literal.mjs";
+import "../_libs/unimport.mjs";
+import "../_libs/picomatch.mjs";
+import "../_libs/fdir.mjs";
+import "../_libs/tinyglobby.mjs";
+import { t as formatCompatibilityDate } from "../_libs/compatx.mjs";
+import "../_libs/klona.mjs";
+import "../_libs/std-env.mjs";
+import "../_libs/dot-prop.mjs";
+import { n as writeTypes, o as scanHandlers } from "../_chunks/B5ooyfLk.mjs";
+import "../_libs/mime.mjs";
+import "../_libs/pathe.mjs";
+import "../_libs/untyped.mjs";
+import "../_libs/knitwork.mjs";
+import { i as watch$1 } from "../_libs/chokidar.mjs";
+import "../_libs/etag.mjs";
+import "../_libs/estree-walker.mjs";
+import "../_libs/plugin-commonjs.mjs";
+import "../_libs/plugin-replace.mjs";
+import { i as replace, n as baseBuildPlugins, r as baseBuildConfig, t as writeBuildInfo } from "./common.mjs";
+import "../_libs/remapping.mjs";
+import "../_libs/unwasm.mjs";
+import { i as raw, n as generateFSTree, r as nitroServerName, t as snapshot } from "../_chunks/B3asVbT4.mjs";
+import "../_libs/duplexer.mjs";
+import "../_libs/gzip-size.mjs";
+import "../_libs/pretty-bytes.mjs";
+import { builtinModules } from "node:module";
+import { watch } from "node:fs";
+import { defu } from "defu";
+import { runtimeDir } from "nitro/runtime/meta";
+
+//#region src/build/rolldown/config.ts
+const getRolldownConfig = (nitro) => {
+	const base = baseBuildConfig(nitro);
+	const chunkNamePrefixes = [
+		[nitro.options.buildDir, "build"],
+		[base.buildServerDir, "app"],
+		[runtimeDir, "nitro"],
+		[base.presetsDir, "nitro"],
+		["\0raw:", "raw"],
+		["\0nitro-wasm:", "wasm"],
+		["\0", "virtual"]
+	];
+	let config = {
+		cwd: nitro.options.rootDir,
+		input: nitro.options.entry,
+		external: [
+			...base.env.external,
+			...builtinModules,
+			...builtinModules.map((m) => `node:${m}`)
+		],
+		plugins: [
+			...baseBuildPlugins(nitro, base),
+			replace({
+				delimiters: base.replaceDelimiters,
+				preventAssignment: true,
+				values: base.replacements
+			}),
+			raw()
+		],
+		resolve: {
+			alias: base.aliases,
+			extensions: base.extensions,
+			mainFields: ["main"],
+			conditionNames: nitro.options.exportConditions
+		},
+		transform: {
+			inject: base.env.inject,
+			jsx: {
+				runtime: "classic",
+				pragma: nitro.options.esbuild?.options?.jsxFactory,
+				pragmaFrag: nitro.options.esbuild?.options?.jsxFragment,
+				development: nitro.options.dev
+			}
+		},
+		onwarn(warning, warn) {
+			if (!["CIRCULAR_DEPENDENCY", "EVAL"].includes(warning.code || "") && !warning.message.includes("Unsupported source map comment")) warn(warning);
+		},
+		treeshake: { moduleSideEffects(id) {
+			const normalizedId = normalize(id);
+			const idWithoutNodeModules = normalizedId.split("node_modules/").pop();
+			if (!idWithoutNodeModules) return false;
+			if (normalizedId.startsWith(runtimeDir) || idWithoutNodeModules.startsWith(runtimeDir)) return true;
+			return nitro.options.moduleSideEffects.some((m) => normalizedId.startsWith(m) || idWithoutNodeModules.startsWith(m));
+		} },
+		output: {
+			dir: nitro.options.output.serverDir,
+			entryFileNames: "index.mjs",
+			minify: nitro.options.minify,
+			chunkFileNames(chunk) {
+				const id = normalize(chunk.moduleIds.at(-1) || "");
+				for (const [dir, name] of chunkNamePrefixes) if (id.startsWith(dir)) return `chunks/${name}/[name].mjs`;
+				const routeHandler = nitro.options.handlers.find((h) => id.startsWith(h.handler)) || nitro.scannedHandlers.find((h) => id.startsWith(h.handler));
+				if (routeHandler?.route) return `chunks/routes${routeHandler.route.replace(/:([^/]+)/g, "_$1").replace(/\/[^/]+$/g, "") || "/"}/[name].mjs`;
+				if (Object.entries(nitro.options.tasks).find(([_, task]) => task.handler === id)) return `chunks/tasks/[name].mjs`;
+				return `chunks/_/[name].mjs`;
+			},
+			inlineDynamicImports: nitro.options.inlineDynamicImports,
+			format: "esm",
+			exports: "auto",
+			intro: "",
+			outro: "",
+			sanitizeFileName: sanitizeFilePath,
+			sourcemap: nitro.options.sourceMap,
+			sourcemapIgnoreList(relativePath) {
+				return relativePath.includes("node_modules");
+			}
+		}
+	};
+	config = defu(nitro.options.rollupConfig, config);
+	return config;
+};
+
+//#endregion
+//#region src/build/rolldown/dev.ts
+async function watchDev(nitro, config) {
+	const rolldown = await import("rolldown");
+	let watcher;
+	async function load() {
+		if (watcher) await watcher.close();
+		await scanHandlers(nitro);
+		nitro.routing.sync();
+		watcher = startWatcher(nitro, config);
+		await writeTypes(nitro);
+	}
+	const reload = debounce(load);
+	const scanDirs = nitro.options.scanDirs.flatMap((dir) => [
+		join(dir, nitro.options.apiDir || "api"),
+		join(dir, nitro.options.routesDir || "routes"),
+		join(dir, "middleware"),
+		join(dir, "plugins"),
+		join(dir, "modules")
+	]);
+	const watchReloadEvents = new Set([
+		"add",
+		"addDir",
+		"unlink",
+		"unlinkDir"
+	]);
+	const scanDirsWatcher = watch$1(scanDirs, { ignoreInitial: true }).on("all", (event) => {
+		if (watchReloadEvents.has(event)) reload();
+	});
+	const srcDirWatcher = watch(nitro.options.srcDir, { persistent: false }, (_event, filename) => {
+		if (filename && /^server\.[mc]?[jt]sx?$/.test(filename)) reload();
+	});
+	nitro.hooks.hook("close", () => {
+		watcher.close();
+		scanDirsWatcher.close();
+		srcDirWatcher.close();
+	});
+	nitro.hooks.hook("rollup:reload", () => reload());
+	await load();
+	function startWatcher(nitro$1, config$1) {
+		const watcher$1 = rolldown.watch(config$1);
+		let start;
+		watcher$1.on("event", (event) => {
+			switch (event.code) {
+				case "START":
+					start = Date.now();
+					nitro$1.hooks.callHook("dev:start");
+					break;
+				case "BUNDLE_END":
+					nitro$1.hooks.callHook("compiled", nitro$1);
+					if (nitro$1.options.logging.buildSuccess) nitro$1.logger.success(`${nitroServerName(nitro$1)} built with rolldown`, start ? `in ${Date.now() - start}ms` : "");
+					nitro$1.hooks.callHook("dev:reload");
+					break;
+				case "ERROR": nitro$1.hooks.callHook("dev:error", event.error);
+			}
+		});
+		return watcher$1;
+	}
+}
+
+//#endregion
+//#region src/build/rolldown/prod.ts
+async function buildProduction(nitro, config) {
+	const rolldown = await import("rolldown");
+	await scanHandlers(nitro);
+	await writeTypes(nitro);
+	await snapshot(nitro);
+	if (!nitro.options.static) {
+		nitro.logger.info(`Building ${nitroServerName(nitro)} (rolldown, preset: \`${nitro.options.preset}\`, compatibility date: \`${formatCompatibilityDate(nitro.options.compatibilityDate)}\`)`);
+		await (await rolldown.rolldown(config)).write(config.output);
+	}
+	const buildInfo = await writeBuildInfo(nitro);
+	if (!nitro.options.static) {
+		if (nitro.options.logging.buildSuccess) nitro.logger.success(`${nitroServerName(nitro)} built`);
+		if (nitro.options.logLevel > 1) process.stdout.write(await generateFSTree(nitro.options.output.serverDir, { compressedSizes: nitro.options.logging.compressedSizes }) || "");
+	}
+	await nitro.hooks.callHook("compiled", nitro);
+	const rOutput = relative(process.cwd(), nitro.options.output.dir);
+	const rewriteRelativePaths = (input) => {
+		return input.replace(/([\s:])\.\/(\S*)/g, `$1${rOutput}/$2`);
+	};
+	if (buildInfo.commands.preview) nitro.logger.success(`You can preview this build using \`${rewriteRelativePaths(buildInfo.commands.preview)}\``);
+	if (buildInfo.commands.deploy) nitro.logger.success(`You can deploy this build using \`${rewriteRelativePaths(buildInfo.commands.deploy)}\``);
+}
+
+//#endregion
+//#region src/build/rolldown/build.ts
+async function rolldownBuild(nitro) {
+	await nitro.hooks.callHook("build:before", nitro);
+	const config = getRolldownConfig(nitro);
+	await nitro.hooks.callHook("rollup:before", nitro, config);
+	return nitro.options.dev ? watchDev(nitro, config) : buildProduction(nitro, config);
+}
+
+//#endregion
+export { rolldownBuild };

package/dist/_build/rollup.mjs

@@ -0,0 +1,359 @@
+import { b as join, n as debounce, v as extname, w as relative, x as normalize, y as isAbsolute } from "../_libs/c12.mjs";
+import "../_libs/gen-mapping.mjs";
+import "../_libs/magic-string.mjs";
+import "../_libs/acorn.mjs";
+import "../_libs/confbox.mjs";
+import { f as sanitizeFilePath } from "../_libs/local-pkg.mjs";
+import "../_libs/js-tokens.mjs";
+import "../_libs/strip-literal.mjs";
+import { a as createFilter } from "../_libs/unimport.mjs";
+import "../_libs/picomatch.mjs";
+import "../_libs/fdir.mjs";
+import "../_libs/tinyglobby.mjs";
+import { t as formatCompatibilityDate } from "../_libs/compatx.mjs";
+import "../_libs/klona.mjs";
+import "../_libs/std-env.mjs";
+import "../_libs/dot-prop.mjs";
+import { n as writeTypes, o as scanHandlers } from "../_chunks/B5ooyfLk.mjs";
+import "../_libs/mime.mjs";
+import "../_libs/pathe.mjs";
+import "../_libs/untyped.mjs";
+import "../_libs/knitwork.mjs";
+import { i as watch$1 } from "../_libs/chokidar.mjs";
+import "../_libs/etag.mjs";
+import { t as alias } from "../_libs/plugin-alias.mjs";
+import "../_libs/estree-walker.mjs";
+import { t as commonjs } from "../_libs/plugin-commonjs.mjs";
+import { t as inject } from "../_libs/plugin-inject.mjs";
+import "../_libs/plugin-replace.mjs";
+import { i as replace, n as baseBuildPlugins, r as baseBuildConfig, t as writeBuildInfo } from "./common.mjs";
+import "../_libs/remapping.mjs";
+import "../_libs/unwasm.mjs";
+import { i as raw, n as generateFSTree, r as nitroServerName, t as snapshot } from "../_chunks/B3asVbT4.mjs";
+import "../_libs/duplexer.mjs";
+import "../_libs/gzip-size.mjs";
+import "../_libs/pretty-bytes.mjs";
+import "../_libs/commondir.mjs";
+import "../_libs/is-reference.mjs";
+import { t as json } from "../_libs/plugin-json.mjs";
+import "../_libs/deepmerge.mjs";
+import "../_libs/is-module.mjs";
+import { t as nodeResolve } from "../_libs/plugin-node-resolve.mjs";
+import "../_libs/path-parse.mjs";
+import "../_libs/function-bind.mjs";
+import "../_libs/hasown.mjs";
+import "../_libs/is-core-module.mjs";
+import { createRequire } from "node:module";
+import { watch } from "node:fs";
+import { defu } from "defu";
+import { runtimeDir } from "nitro/runtime/meta";
+import { transform } from "esbuild";
+
+//#region src/build/plugins/esbuild.ts
+const defaultLoaders = {
+	".ts": "ts",
+	".js": "js",
+	".tsx": "tsx",
+	".jsx": "jsx"
+};
+function esbuild(options) {
+	const { include, exclude, sourceMap, loaders: loadersConfig, minify,...transformOptions } = options;
+	const loaders = { ...defaultLoaders };
+	if (loadersConfig) for (const key of Object.keys(loadersConfig)) {
+		const value = loadersConfig[key];
+		if (typeof value === "string") loaders[key] = value;
+		else if (value === false) delete loaders[key];
+	}
+	const extensions = Object.keys(loaders);
+	const INCLUDE_REGEXP = /* @__PURE__ */ new RegExp(`\\.(${extensions.map((ext) => ext.slice(1)).join("|")})$`);
+	const filter = createFilter(include || INCLUDE_REGEXP, exclude || /node_modules/);
+	return {
+		name: "esbuild",
+		async transform(code, id) {
+			if (!filter(id)) return null;
+			const loader = loaders[extname(id)];
+			if (!loader) return null;
+			const result = await transform(code, {
+				sourcemap: sourceMap === "hidden" ? "external" : sourceMap,
+				...transformOptions,
+				loader,
+				sourcefile: id
+			});
+			printWarnings(id, result, this);
+			return result.code && {
+				code: result.code,
+				map: result.map || null
+			};
+		},
+		async renderChunk(code) {
+			if (minify) {
+				const result = await transform(code, {
+					loader: "js",
+					minify: true,
+					target: transformOptions.target
+				});
+				if (result.code) return {
+					code: result.code,
+					map: result.map || null
+				};
+			}
+			return null;
+		}
+	};
+}
+function printWarnings(id, result, plugin) {
+	if (result.warnings) for (const warning of result.warnings) {
+		let message = "[esbuild]";
+		if (warning.location) message += ` (${relative(process.cwd(), id)}:${warning.location.line}:${warning.location.column})`;
+		message += ` ${warning.text}`;
+		plugin.warn(message);
+	}
+}
+
+//#endregion
+//#region src/build/plugins/sourcemap-min.ts
+function sourcemapMininify() {
+	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);
+				if (!(sourcemap.sources || []).some((s) => s.includes("node_modules"))) continue;
+				sourcemap.mappings = "";
+				asset.source = JSON.stringify(sourcemap);
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/build/rollup/config.ts
+const getRollupConfig = (nitro) => {
+	const base = baseBuildConfig(nitro);
+	const chunkNamePrefixes = [
+		[nitro.options.buildDir, "build"],
+		[base.buildServerDir, "app"],
+		[runtimeDir, "nitro"],
+		[base.presetsDir, "nitro"],
+		["\0raw:", "raw"],
+		["\0nitro-wasm:", "wasm"],
+		["\0", "virtual"]
+	];
+	function getChunkGroup(id) {
+		if (id.startsWith(runtimeDir) || id.startsWith(base.presetsDir)) return "nitro";
+	}
+	let config = {
+		input: nitro.options.entry,
+		external: [...base.env.external],
+		plugins: [
+			...baseBuildPlugins(nitro, base),
+			esbuild({
+				target: "esnext",
+				sourceMap: nitro.options.sourceMap,
+				...nitro.options.esbuild?.options
+			}),
+			alias({ entries: base.aliases }),
+			replace({
+				delimiters: base.replaceDelimiters,
+				preventAssignment: true,
+				values: base.replacements
+			}),
+			nodeResolve({
+				extensions: base.extensions,
+				preferBuiltins: !!nitro.options.node,
+				rootDir: nitro.options.rootDir,
+				modulePaths: nitro.options.nodeModulesDirs,
+				mainFields: ["main"],
+				exportConditions: nitro.options.exportConditions
+			}),
+			commonjs({
+				strictRequires: "auto",
+				esmExternals: (id) => !id.startsWith("unenv/"),
+				requireReturnsDefault: "auto",
+				...nitro.options.commonJS
+			}),
+			json(),
+			inject(base.env.inject),
+			raw()
+		],
+		onwarn(warning, rollupWarn) {
+			if (![
+				"EVAL",
+				"CIRCULAR_DEPENDENCY",
+				"THIS_IS_UNDEFINED"
+			].includes(warning.code || "") && !warning.message.includes("Unsupported source map comment")) rollupWarn(warning);
+		},
+		treeshake: { moduleSideEffects(id) {
+			const normalizedId = normalize(id);
+			const idWithoutNodeModules = normalizedId.split("node_modules/").pop();
+			if (!idWithoutNodeModules) return false;
+			if (normalizedId.startsWith(runtimeDir) || idWithoutNodeModules.startsWith(runtimeDir)) return true;
+			return nitro.options.moduleSideEffects.some((m) => normalizedId.startsWith(m) || idWithoutNodeModules.startsWith(m));
+		} },
+		output: {
+			dir: nitro.options.output.serverDir,
+			entryFileNames: "index.mjs",
+			chunkFileNames(chunk) {
+				const id = normalize(chunk.moduleIds.at(-1) || "");
+				for (const [dir, name] of chunkNamePrefixes) if (id.startsWith(dir)) return `chunks/${name}/[name].mjs`;
+				const routeHandler = nitro.options.handlers.find((h) => id.startsWith(h.handler)) || nitro.scannedHandlers.find((h) => id.startsWith(h.handler));
+				if (routeHandler?.route) return `chunks/routes${routeHandler.route.replace(/:([^/]+)/g, "_$1").replace(/\/[^/]+$/g, "") || "/"}/[name].mjs`;
+				if (Object.entries(nitro.options.tasks).find(([_, task]) => task.handler === id)) return `chunks/tasks/[name].mjs`;
+				return `chunks/_/[name].mjs`;
+			},
+			manualChunks(id) {
+				return getChunkGroup(id);
+			},
+			inlineDynamicImports: nitro.options.inlineDynamicImports,
+			format: "esm",
+			exports: "auto",
+			intro: "",
+			outro: "",
+			generatedCode: { constBindings: true },
+			sanitizeFileName: sanitizeFilePath,
+			sourcemap: nitro.options.sourceMap,
+			sourcemapExcludeSources: true,
+			sourcemapIgnoreList(relativePath) {
+				return relativePath.includes("node_modules");
+			}
+		}
+	};
+	config = defu(nitro.options.rollupConfig, config);
+	if (config.output.inlineDynamicImports) delete config.output.manualChunks;
+	if (nitro.options.minify) {
+		const _terser = createRequire(import.meta.url)("@rollup/plugin-terser");
+		const terser = _terser.default || _terser;
+		config.plugins.push(terser({
+			mangle: {
+				keep_fnames: true,
+				keep_classnames: true
+			},
+			format: { comments: false }
+		}));
+	}
+	if (nitro.options.sourceMap && !nitro.options.dev && nitro.options.experimental.sourcemapMinify !== false) config.plugins.push(sourcemapMininify());
+	return config;
+};
+
+//#endregion
+//#region src/build/rollup/error.ts
+function formatRollupError(_error) {
+	try {
+		const logs = [_error.toString()];
+		const errors = _error?.errors || [_error];
+		for (const error of errors) {
+			const id = error.path || error.id || _error.id;
+			let path = isAbsolute(id) ? relative(process.cwd(), id) : id;
+			const location = error.loc || error.location;
+			if (location) path += `:${location.line}:${location.column}`;
+			const text = error.text || error.frame;
+			logs.push(`Rollup error while processing \`${path}\`` + text ? "\n\n" + text : "");
+		}
+		return logs.join("\n");
+	} catch {
+		return _error?.toString();
+	}
+}
+
+//#endregion
+//#region src/build/rollup/dev.ts
+async function watchDev(nitro, rollupConfig) {
+	const rollup = await import("rollup");
+	let rollupWatcher;
+	async function load() {
+		if (rollupWatcher) await rollupWatcher.close();
+		await scanHandlers(nitro);
+		nitro.routing.sync();
+		rollupWatcher = startRollupWatcher(nitro, rollupConfig);
+		await writeTypes(nitro);
+	}
+	const reload = debounce(load);
+	const scanDirs = nitro.options.scanDirs.flatMap((dir) => [
+		join(dir, nitro.options.apiDir || "api"),
+		join(dir, nitro.options.routesDir || "routes"),
+		join(dir, "middleware"),
+		join(dir, "plugins"),
+		join(dir, "modules")
+	]);
+	const watchReloadEvents = new Set([
+		"add",
+		"addDir",
+		"unlink",
+		"unlinkDir"
+	]);
+	const scanDirsWatcher = watch$1(scanDirs, { ignoreInitial: true }).on("all", (event, path, stat) => {
+		if (watchReloadEvents.has(event)) reload();
+	});
+	const srcDirWatcher = watch(nitro.options.srcDir, { persistent: false }, (_event, filename) => {
+		if (filename && /^server\.[mc]?[jt]sx?$/.test(filename)) reload();
+	});
+	nitro.hooks.hook("close", () => {
+		rollupWatcher.close();
+		scanDirsWatcher.close();
+		srcDirWatcher.close();
+	});
+	nitro.hooks.hook("rollup:reload", () => reload());
+	await load();
+	function startRollupWatcher(nitro$1, rollupConfig$1) {
+		const watcher = rollup.watch(defu(rollupConfig$1, { watch: { chokidar: nitro$1.options.watchOptions } }));
+		let start;
+		watcher.on("event", (event) => {
+			switch (event.code) {
+				case "START":
+					start = Date.now();
+					nitro$1.hooks.callHook("dev:start");
+					break;
+				case "BUNDLE_END":
+					nitro$1.hooks.callHook("compiled", nitro$1);
+					if (nitro$1.options.logging.buildSuccess) nitro$1.logger.success(`${nitroServerName(nitro$1)} built with rollup`, start ? `in ${Date.now() - start}ms` : "");
+					nitro$1.hooks.callHook("dev:reload");
+					break;
+				case "ERROR":
+					nitro$1.logger.error(formatRollupError(event.error));
+					nitro$1.hooks.callHook("dev:error", event.error);
+			}
+		});
+		return watcher;
+	}
+}
+
+//#endregion
+//#region src/build/rollup/prod.ts
+async function buildProduction(nitro, rollupConfig) {
+	const rollup = await import("rollup");
+	await scanHandlers(nitro);
+	await writeTypes(nitro);
+	await snapshot(nitro);
+	if (!nitro.options.static) {
+		nitro.logger.info(`Building ${nitroServerName(nitro)} (rollup, preset: \`${nitro.options.preset}\`, compatibility date: \`${formatCompatibilityDate(nitro.options.compatibilityDate)}\`)`);
+		await (await rollup.rollup(rollupConfig).catch((error) => {
+			nitro.logger.error(formatRollupError(error));
+			throw error;
+		})).write(rollupConfig.output);
+	}
+	const buildInfo = await writeBuildInfo(nitro);
+	if (!nitro.options.static) {
+		if (nitro.options.logging.buildSuccess) nitro.logger.success(`${nitroServerName(nitro)} built`);
+		if (nitro.options.logLevel > 1) process.stdout.write(await generateFSTree(nitro.options.output.serverDir, { compressedSizes: nitro.options.logging.compressedSizes }) || "");
+	}
+	await nitro.hooks.callHook("compiled", nitro);
+	const rOutput = relative(process.cwd(), nitro.options.output.dir);
+	const rewriteRelativePaths = (input) => {
+		return input.replace(/([\s:])\.\/(\S*)/g, `$1${rOutput}/$2`);
+	};
+	if (buildInfo.commands.preview) nitro.logger.success(`You can preview this build using \`${rewriteRelativePaths(buildInfo.commands.preview)}\``);
+	if (buildInfo.commands.deploy) nitro.logger.success(`You can deploy this build using \`${rewriteRelativePaths(buildInfo.commands.deploy)}\``);
+}
+
+//#endregion
+//#region src/build/rollup/build.ts
+async function rollupBuild(nitro) {
+	await nitro.hooks.callHook("build:before", nitro);
+	const config = getRollupConfig(nitro);
+	await nitro.hooks.callHook("rollup:before", nitro, config);
+	return nitro.options.dev ? watchDev(nitro, config) : buildProduction(nitro, config);
+}
+
+//#endregion
+export { rollupBuild };

package/dist/_build/vite.build.mjs

@@ -0,0 +1,67 @@
+import "../_libs/c12.mjs";
+import "../_libs/gen-mapping.mjs";
+import "../_libs/magic-string.mjs";
+import "../_libs/acorn.mjs";
+import "../_libs/confbox.mjs";
+import "../_libs/local-pkg.mjs";
+import "../_libs/js-tokens.mjs";
+import "../_libs/strip-literal.mjs";
+import "../_libs/unimport.mjs";
+import "../_libs/picomatch.mjs";
+import "../_libs/fdir.mjs";
+import "../_libs/tinyglobby.mjs";
+import "../_libs/compatx.mjs";
+import "../_libs/klona.mjs";
+import { n as a } from "../_libs/std-env.mjs";
+import "../_chunks/B-7HiF0V.mjs";
+import "../_libs/escape-string-regexp.mjs";
+import "../_libs/dot-prop.mjs";
+import "../_chunks/B5ooyfLk.mjs";
+import "../_libs/rou3.mjs";
+import "../_libs/mime.mjs";
+import "../_libs/pathe.mjs";
+import "../_libs/untyped.mjs";
+import "../_libs/knitwork.mjs";
+import "../_libs/httpxy.mjs";
+import "../_dev.mjs";
+import "../_libs/chokidar.mjs";
+import "../_libs/encodeurl.mjs";
+import "../_libs/escape-html.mjs";
+import "../_libs/parseurl.mjs";
+import "../_libs/depd.mjs";
+import "../_libs/http-errors.mjs";
+import "../_libs/debug.mjs";
+import "../_libs/etag.mjs";
+import "../_libs/fresh.mjs";
+import "../_libs/mime-db.mjs";
+import "../_libs/mime-types.mjs";
+import "../_libs/ee-first.mjs";
+import "../_libs/on-finished.mjs";
+import "../_libs/range-parser.mjs";
+import "../_libs/send.mjs";
+import "../_libs/serve-static.mjs";
+import "../_libs/ultrahtml.mjs";
+import "../_libs/plugin-alias.mjs";
+import "../_libs/estree-walker.mjs";
+import "../_libs/plugin-commonjs.mjs";
+import "../_libs/plugin-inject.mjs";
+import "../_libs/plugin-replace.mjs";
+import "./common.mjs";
+import "../_libs/remapping.mjs";
+import "../_libs/unwasm.mjs";
+import { t as nitro } from "./vite.plugin.mjs";
+import "../_libs/vite-plugin-fullstack.mjs";
+
+//#region src/build/vite/build.ts
+async function viteBuild(nitro$1) {
+	if (nitro$1.options.dev) throw new Error("Nitro vite builder is not supported in development mode. Please use `vite dev` instead.");
+	const { createBuilder } = await import("vite");
+	await (await createBuilder({
+		base: nitro$1.options.rootDir,
+		plugins: [await nitro({ _nitro: nitro$1 })],
+		logLevel: a ? "warn" : void 0
+	})).buildApp();
+}
+
+//#endregion
+export { viteBuild };