nitro-nightly 3.0.260429-beta → 3.0.260522-beta

package/dist/_build/common.mjs

@@ -1,4 +1,4 @@
-import { i as __toESM$1, n as __exportAll, r as __require$1, t as __commonJSMin } from "../_common.mjs";
+import { __commonJSMin, __exportAll, __require as __require$1, __toESM as __toESM$1 } from "../_common.mjs";
 import { builtinModules, createRequire } from "node:module";
 import consola from "consola";
 import { pkgDir, runtimeDependencies, runtimeDir, version } from "nitro/meta";
@@ -188,7 +188,6 @@ const parse$1 = function(p) {
 		name: base.slice(0, base.length - extension.length)
 	};
 };
-globalThis.process?.platform;
 const nodeBuiltins = [
 	"_http_agent",
 	"_http_client",
@@ -948,8 +947,8 @@ function moduleResolve$1(specifier, base, conditions, preserveSymlinks) {
 	return finalizeResolution$1(resolved, base, preserveSymlinks);
 }
 const DEFAULT_CONDITIONS_SET$2 = /* @__PURE__ */ new Set(["node", "import"]);
-const isWindows = process.platform === "win32";
-const globalCache = globalThis["__EXSOLVE_CACHE__"] ||= /* @__PURE__ */ new Map();
+const isWindows = /* @__PURE__ */ (() => process.platform === "win32")();
+const globalCache = /* @__PURE__ */ (() => globalThis["__EXSOLVE_CACHE__"] ||= /* @__PURE__ */ new Map())();
 function resolveModuleURL(input, options) {
 	const parsedInput = _parseInput(input);
 	if ("external" in parsedInput) return parsedInput.external;
@@ -4281,7 +4280,7 @@ function toPathRegExp(input) {
 	if (typeof input === "string") return new RegExp(pathRegExp(input));
 	throw new TypeError("Expected a string or RegExp", { cause: input });
 }
-const isObject$2 = (value) => {
+const isObject$3 = (value) => {
 	const type = typeof value;
 	return value !== null && (type === "object" || type === "function");
 };
@@ -4402,7 +4401,7 @@ function normalizePath$3(path) {
 	return [];
 }
 function getProperty(object, path, value) {
-	if (!isObject$2(object) || typeof path !== "string" && !Array.isArray(path)) return value === void 0 ? object : value;
+	if (!isObject$3(object) || typeof path !== "string" && !Array.isArray(path)) return value === void 0 ? object : value;
 	const pathArray = normalizePath$3(path);
 	if (pathArray.length === 0) return value;
 	for (let index = 0; index < pathArray.length; index++) {
@@ -15681,6 +15680,9 @@ const BUILTIN_MODULES = new Set(builtinModules);
 function normalizeSlash(path) {
 	return path.replace(/\\/g, "/");
 }
+function isObject$2(value) {
+	return value !== null && typeof value === "object";
+}
 function matchAll(regex, string, addition) {
 	const matches = [];
 	for (const match of string.matchAll(regex)) matches.push({
@@ -16739,6 +16741,23 @@ function _isIdentifierBeforeAngleBracket(str, i) {
 	const wordStart = j + 1;
 	return wordStart < i && /[A-Za-z_$]/.test(str[wordStart]);
 }
+function interopDefault(sourceModule, opts = {}) {
+	if (!isObject$2(sourceModule) || !("default" in sourceModule)) return sourceModule;
+	const defaultValue = sourceModule.default;
+	if (defaultValue === void 0 || defaultValue === null) return sourceModule;
+	const _defaultType = typeof defaultValue;
+	if (_defaultType !== "object" && !(_defaultType === "function" && !opts.preferNamespace)) return opts.preferNamespace ? sourceModule : defaultValue;
+	for (const key in sourceModule) try {
+		if (!(key in defaultValue)) Object.defineProperty(defaultValue, key, {
+			enumerable: key !== "default",
+			configurable: key !== "default",
+			get() {
+				return sourceModule[key];
+			}
+		});
+	} catch {}
+	return defaultValue;
+}
 const ESM_RE = /(?:[\s;]|^)(?:import[\s\w*,{}]*from|import\s*["'*{]|export\b\s*(?:[*{]|default|class|type|function|const|var|let|async function)|import\.meta\b)/m;
 const CJS_RE = /(?:[\s;]|^)(?:module\.exports\b|exports\.\w|require\s*\(|global\.\w)/m;
 const COMMENT_RE = /\/\*.+?\*\/|\/\/.*(?=[nr])/g;
@@ -19301,6 +19320,14 @@ function resolveModule(name, options = {}) {
 		return;
 	}
 }
+async function importModule(path) {
+	const i = await import(path);
+	if (i) return interopDefault(i);
+	return i;
+}
+function isPackageExists(name, options = {}) {
+	return !!resolvePackage(name, options);
+}
 function getPackageJsonPath(name, options = {}) {
 	const entry = resolvePackage(name, options);
 	if (!entry) return;
@@ -19359,7 +19386,7 @@ quansync(function* (name, cwd) {
 	const pkg = (yield loadPackageJSON(cwd)) || {};
 	return name in (pkg.dependencies || {}) || name in (pkg.devDependencies || {});
 }).sync;
-const version$1 = "6.2.0";
+const version$1 = "6.3.0";
 function configureAddons(opts) {
 	const addons = [];
 	if (Array.isArray(opts.addons)) addons.push(...opts.addons);
@@ -19455,8 +19482,8 @@ function parseVirtualImportsRegex(strippedCode, importMap, virtualImports) {
 }
 async function detectImports(code, ctx, options) {
 	switch (options?.parser) {
-		case "acorn": return import("../_libs/unimport+unplugin+oxc-parser.mjs").then((n) => n.r).then((r) => r.detectImportsAcorn(code, ctx, options));
-		case "oxc": return import("../_libs/unimport+unplugin+oxc-parser.mjs").then((n) => n.n).then((r) => r.detectImportsOxc(code, ctx, options));
+		case "acorn": return import("../_libs/unimport+unplugin.mjs").then((n) => n.detect_acorn_exports).then((r) => r.detectImportsAcorn(code, ctx, options));
+		case "oxc": return import("../_libs/unimport+unplugin.mjs").then((n) => n.detect_oxc_exports).then((r) => r.detectImportsOxc(code, ctx, options));
 		default: return detectImportsRegex(code, ctx, options);
 	}
 }
@@ -19567,7 +19594,8 @@ async function scanFilesFromDir(dir, options) {
 		expandDirectories: false
 	})).map((i) => normalize$2(i));
 	const fileFilter = options?.fileFilter || (() => true);
-	const indexOfDirs = (file) => dirGlobs.findIndex((glob2) => import_picomatch.default.isMatch(file, glob2));
+	const dirMatchers = dirGlobs.map((glob2) => (0, import_picomatch.default)(glob2));
+	const indexOfDirs = (file) => dirMatchers.findIndex((match) => match(file));
 	return files.reduce((acc, file) => {
 		const index = indexOfDirs(file);
 		if (acc[index]) acc[index].push(normalize$2(file));
@@ -19578,8 +19606,8 @@ async function scanFilesFromDir(dir, options) {
 async function scanDirExports(dirs, options) {
 	const normalizedDirs = normalizeScanDirs(dirs, options);
 	const files = await scanFilesFromDir(normalizedDirs, options);
-	const includeTypesDirs = normalizedDirs.filter((dir) => !dir.glob.startsWith("!") && dir.types);
-	const isIncludeTypes = (file) => includeTypesDirs.some((dir) => import_picomatch.default.isMatch(file, dir.glob));
+	const includeTypesMatchers = normalizedDirs.filter((dir) => !dir.glob.startsWith("!") && dir.types).map((dir) => (0, import_picomatch.default)(dir.glob));
+	const isIncludeTypes = (file) => includeTypesMatchers.some((match) => match(file));
 	return dedupeDtsExports((await Promise.all(files.map((file) => scanExports(file, isIncludeTypes(file))))).flat());
 }
 function dedupeDtsExports(exports) {
@@ -21104,6 +21132,72 @@ function joinPkgNames(moduleIds) {
 function routeToFsPath(route) {
 	return route.split("/").slice(1).map((s) => s.replace(/:(\w+)/g, "[$1]").replace(/\*+/g, "[...]").replace(/[^a-zA-Z0-9_.[\]]/g, "_")).join("/") || "index";
 }
+function app(nitro) {
+	return {
+		id: "#nitro/virtual/app",
+		template: () => {
+			const hasRoutes = nitro.routing.routes.hasRoutes();
+			const hasRouteRules = nitro.routing.routeRules.hasRoutes();
+			const hasRoutedMiddleware = nitro.routing.routedMiddleware.hasRoutes();
+			const hasGlobalMiddleware = nitro.routing.globalMiddleware.length > 0;
+			const hasPlugins = nitro.options.plugins.length > 0;
+			const hasHooks = nitro.options.features?.runtimeHooks ?? hasPlugins;
+			const hasGetMiddleware = hasRouteRules || hasRoutedMiddleware;
+			const hasAsyncContext = !!nitro.options.experimental.asyncContext;
+			const routingImports = [
+				hasRoutes && "findRoute",
+				hasRoutedMiddleware && "findRoutedMiddleware",
+				hasGlobalMiddleware && "globalMiddleware"
+			].filter(Boolean);
+			const imports = [];
+			const code = [];
+			imports.push(`import { H3Core } from "h3";`, `import errorHandler from "#nitro/virtual/error-handler";`);
+			code.push(``, `export function createNitroApp() {`);
+			if (hasHooks) {
+				imports.push(`import { HookableCore } from "hookable";`);
+				code.push(`  const hooks = new HookableCore();`);
+			}
+			code.push(``, `const captureError = (error, errorCtx) => {`);
+			if (hasHooks) code.push(`    const promise = hooks.callHook("error", error, errorCtx)?.catch?.((hookError) => {`, `      console.error("Error while capturing another error", hookError);`, `    });`);
+			code.push(`    if (errorCtx?.event) {`, `      const errors = errorCtx.event.req.context?.nitro?.errors;`, `      if (errors) {`, `        errors.push({ error, context: errorCtx });`, `      }`);
+			if (hasHooks) code.push(`      if (promise && typeof errorCtx.event.req.waitUntil === "function") {`, `        errorCtx.event.req.waitUntil(promise);`, `      }`);
+			code.push(`    }`, `  };`);
+			code.push(``, `  const h3App = createH3App({`, `    onError(error, event) {`);
+			if (hasHooks) code.push(`      captureError(error, { event });`);
+			code.push(`      return errorHandler(error, event);`, `    },`, `  });`);
+			if (hasHooks) code.push(``, `  h3App.config.onRequest = (event) => {`, `    return hooks.callHook("request", event)?.catch?.((error) => {`, `      captureError(error, { event, tags: ["request"] });`, `    });`, `  };`, `  h3App.config.onResponse = (res, event) => {`, `    return hooks.callHook("response", res, event)?.catch?.((error) => {`, `      captureError(error, { event, tags: ["response"] });`, `    });`, `  };`);
+			code.push(``, `  let appHandler = (req) => {`, `    req.context ||= {};`, `    req.context.nitro = req.context.nitro || { errors: [] };`, `    return h3App.fetch(req);`, `  };`);
+			if (hasAsyncContext) {
+				imports.push(`import { nitroAsyncContext } from "#nitro/runtime/context";`);
+				code.push(``, `  const originalHandler = appHandler;`, `  appHandler = (req) => {`, `    return nitroAsyncContext.callAsync({ request: req }, () => originalHandler(req));`, `  };`);
+			}
+			code.push(``, `  return {`, `    fetch: appHandler,`, `    h3: h3App,`, `    hooks: ${hasHooks ? "hooks" : "undefined"},`, `    captureError,`, `  };`, `}`);
+			code.push(``, `export function initNitroPlugins(app) {`);
+			if (hasPlugins) {
+				imports.push(`import { plugins } from "#nitro/virtual/plugins";`);
+				code.push(`  for (const plugin of plugins) {`, `    try {`, `      plugin(app);`, `    } catch (error) {`, `      app.captureError?.(error, { tags: ["plugin"] });`, `      throw error;`, `    }`, `  }`);
+			}
+			code.push(`  return app;`, `}`);
+			if (routingImports.length) imports.push(`import { ${routingImports.join(", ")} } from "#nitro/virtual/routing";`);
+			code.push(``, `function createH3App(config) {`, `  const h3App = new H3Core(config);`);
+			if (hasRoutes) code.push(`  h3App["~findRoute"] = (event) => findRoute(event.req.method, event.url.pathname);`);
+			if (hasGlobalMiddleware) code.push(`  h3App["~middleware"].push(...globalMiddleware);`);
+			if (hasGetMiddleware) {
+				code.push(`  h3App["~getMiddleware"] = (event, route) => {`, `    const pathname = event.url.pathname;`, `    const method = event.req.method;`, `    const middleware = [];`);
+				if (hasRouteRules) {
+					imports.push(`import { getRouteRules } from "#nitro/runtime/app";`);
+					code.push(`    const routeRules = getRouteRules(method, pathname);`, `    event.context.routeRules = routeRules?.routeRules;`, `    if (routeRules?.routeRuleMiddleware.length) {`, `      middleware.push(...routeRules.routeRuleMiddleware);`, `    }`);
+				}
+				if (hasGlobalMiddleware) code.push(`    middleware.push(...h3App["~middleware"]);`);
+				if (hasRoutedMiddleware) code.push(`    middleware.push(...findRoutedMiddleware(method, pathname).map((r) => r.data));`);
+				if (hasRoutes) code.push(`    if (route?.data?.middleware?.length) {`, `      middleware.push(...route.data.middleware);`, `    }`);
+				code.push(`    return middleware;`, `  };`);
+			}
+			code.push(`  return h3App;`, `}`);
+			return [...imports, ...code].join("\n");
+		}
+	};
+}
 function database(nitro) {
 	return {
 		id: "#nitro/virtual/database",
@@ -21413,10 +21507,11 @@ function routing(nitro) {
 				...Object.values(nitro.routing.routedMiddleware.routes).map((h) => h.data),
 				...nitro.routing.globalMiddleware
 			], "_importHash");
+			const traceH3 = !!nitro.options.tracingChannel?.h3;
 			return `
 import * as __routeRules__ from "#nitro/runtime/route-rules";
 import * as srvxNode from "srvx/node"
-import * as h3 from "h3";
+import * as h3 from "h3";${traceH3 ? `\nimport { wrapHandlerWithTracing } from "h3/tracing";` : ""}
 
 export const findRouteRules = ${nitro.routing.routeRules.compileToString({
 				serialize: serializeRouteRule,
@@ -21433,7 +21528,7 @@ ${allHandlers.filter((h) => !h.lazy).map((h) => `import ${h._importHash} from "$
 
 ${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.routing.routes.compileToString({ serialize: serializeHandler })}
+export const findRoute = ${nitro.routing.routes.compileToString({ serialize: (h) => serializeHandler(h, { tracing: traceH3 }) })}
 
 export const findRoutedMiddleware = ${nitro.routing.routedMiddleware.compileToString({
 				serialize: serializeHandler,
@@ -21450,13 +21545,14 @@ export const globalMiddleware = [
 function uniqueBy(arr, key) {
 	return [...new Map(arr.map((item) => [item[key], item])).values()];
 }
-function serializeHandler(h) {
+function serializeHandler(h, opts = {}) {
 	const meta = Array.isArray(h) ? h[0] : h;
+	const handler = Array.isArray(h) ? `multiHandler(${h.map((handler) => serializeHandlerFn(handler)).join(",")})` : serializeHandlerFn(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)}`
+		`handler:${opts.tracing ? `wrapHandlerWithTracing(${handler})` : handler}`
 	].filter(Boolean).join(",")}}`;
 }
 function serializeHandlerFn(h) {
@@ -21640,6 +21736,7 @@ function tracing(nitro) {
 }
 function virtualTemplates(nitro, _polyfills) {
 	const nitroTemplates = [
+		app,
 		database,
 		errorHandler,
 		featureFlags,
@@ -27829,7 +27926,7 @@ function unwasm(opts) {
 			order: "pre",
 			filter: { id: [
 				/* @__PURE__ */ new RegExp("^" + escapeRegExp(UMWASM_HELPERS_ID) + "$"),
-				/* @__PURE__ */ new RegExp("^" + UNWASM_EXTERNAL_PREFIX),
+				/* @__PURE__ */ new RegExp("^\0unwasm:external:"),
 				WASM_ID_RE
 			] },
 			async handler(id, importer) {
@@ -28187,10 +28284,11 @@ function externals(opts) {
 		if (exclude.some((r) => r.test(id))) return false;
 		return true;
 	};
+	const resolveConditions = opts.conditions.includes("import") ? opts.conditions : [...opts.conditions, "import"];
 	const tryResolve = (id, from) => resolveModulePath(id, {
 		try: true,
 		from: from && isAbsolute$2(from) ? from : opts.rootDir,
-		conditions: opts.conditions
+		conditions: resolveConditions
 	});
 	const tracedPaths = /* @__PURE__ */ new Set();
 	if (opts.trace && !resolved?.includePattern) return { name: PLUGIN_NAME };
@@ -28222,7 +28320,7 @@ function externals(opts) {
 					let importId = toImport(id) || toImport(resolvedPath);
 					if (!importId) return resolved;
 					if (!tryResolve(importId, importer)) {
-						const guessed = await guessSubpath(resolvedPath, opts.conditions);
+						const guessed = await guessSubpath(resolvedPath, resolveConditions);
 						if (!guessed) return resolved;
 						importId = guessed;
 					}
@@ -28349,7 +28447,7 @@ async function baseBuildPlugins(nitro, base) {
 	nitro.vfs = virtualPlugin.api.modules;
 	plugins.push(virtualPlugin, virtualDeps());
 	if (nitro.options.imports) {
-		const unimportPlugin = await import("../_libs/unimport+unplugin+oxc-parser.mjs").then((n) => n.t);
+		const unimportPlugin = await import("../_libs/unimport+unplugin.mjs").then((n) => n.unplugin_exports);
 		plugins.push(unimportPlugin.default.rollup(nitro.options.imports));
 	}
 	if (nitro.options.wasm !== false) plugins.push(unwasm(nitro.options.wasm || {}));
@@ -28400,4 +28498,4 @@ async function oxc(options) {
 		}
 	};
 }
-export { yaml_exports as $, src_default as A, _$2 as B, decode as C, copyPublicAssets as D, prepare as E, prettyPath as F, findFile$1 as G, m$2 as H, resolveNitroPath as I, readGitConfig as J, findNearestFile$1 as K, writeFile$1 as L, glob as M, require_picomatch as N, scanUnprefixedPublicAssets as O, Builder as P, a$3 as Q, escapeRegExp$1 as R, MagicString as S, parse as T, v$2 as U, f$1 as V, dist_exports$1 as W, i$3 as X, readPackageJSON$1 as Y, toml_exports as Z, writeTypes as _, dataToEsm as a, basename$2 as at, getMagicString as b, walk as c, isAbsolute$2 as ct, libChunkName as d, relative$2 as dt, jsonc_exports as et, baseBuildConfig as f, resolve$3 as ft, writeDevBuildInfo as g, writeBuildInfo as h, createFilter as i, resolveModuleURL as it, build as j, compressPublicAssets as k, NODE_MODULES_RE$1 as l, join$2 as lt, getBuildInfo as m, baseBuildPlugins as n, json5_exports as nt, extractAssignedNames as o, dirname$2 as ot, runParallel as p, findWorkspaceDir as q, attachScopes as r, resolveModulePath as rt, makeLegalIdentifier as s, extname$4 as st, oxc as t, r$5 as tt, getChunkName as u, normalize$2 as ut, dist_exports as v, encode as w, stripLiteral as x, createUnimport as y, R$1 as z };
+export { Builder, MagicString, NODE_MODULES_RE$1 as NODE_MODULES_RE, R$1 as R, _$2 as _, a$3 as a, attachScopes, baseBuildConfig, baseBuildPlugins, basename$2 as basename, build, compressPublicAssets, copyPublicAssets, createFilter, createUnimport, dataToEsm, decode, dirname$2 as dirname, dist_exports, encode, escapeRegExp$1 as escapeRegExp, extname$4 as extname, extractAssignedNames, f$1 as f, findFile$1 as findFile, findNearestFile$1 as findNearestFile, findWorkspaceDir, getBuildInfo, getChunkName, getMagicString, glob, i$3 as i, importModule, isAbsolute$2 as isAbsolute, isPackageExists, join$2 as join, json5_exports, jsonc_exports, libChunkName, m$2 as m, makeLegalIdentifier, normalize$2 as normalize, oxc, parse, prepare, prettyPath, r$5 as r, readGitConfig, readPackageJSON$1 as readPackageJSON, relative$2 as relative, require_picomatch, resolve$3 as resolve, resolveModulePath, resolveModuleURL, resolveNitroPath, runParallel, scanUnprefixedPublicAssets, src_default, stripLiteral, toml_exports, v$2 as v, walk, writeBuildInfo, writeDevBuildInfo, writeFile$1 as writeFile, writeTypes, yaml_exports };

package/dist/_build/rolldown.mjs

@@ -1,9 +1,9 @@
-import { _ as writeTypes, at as basename, d as libChunkName, dt as relative, f as baseBuildConfig, h as writeBuildInfo, l as NODE_MODULES_RE, lt as join, n as baseBuildPlugins, u as getChunkName } from "./common.mjs";
-import { t as formatCompatibilityDate } from "../_libs/compatx.mjs";
-import { n as scanHandlers } from "../_chunks/nitro2.mjs";
-import { n as watch } from "../_libs/readdirp+chokidar.mjs";
-import { t as debounce } from "../_libs/perfect-debounce.mjs";
-import { n as generateFSTree } from "../_chunks/utils.mjs";
+import { NODE_MODULES_RE, baseBuildConfig, baseBuildPlugins, basename, getChunkName, join, libChunkName, relative, writeBuildInfo, writeTypes } from "./common.mjs";
+import { formatCompatibilityDate } from "../_libs/compatx.mjs";
+import { scanHandlers } from "../_chunks/nitro.mjs";
+import { watch } from "../_libs/readdirp+chokidar.mjs";
+import { debounce } from "../_libs/perfect-debounce.mjs";
+import { generateFSTree } from "../_chunks/utils.mjs";
 import { builtinModules } from "node:module";
 import { defu } from "defu";
 const getRolldownConfig = async (nitro) => {

package/dist/_build/rollup.mjs

@@ -1,14 +1,14 @@
-import { _ as writeTypes, at as basename, ct as isAbsolute, d as libChunkName, dt as relative, f as baseBuildConfig, h as writeBuildInfo, l as NODE_MODULES_RE, lt as join, n as baseBuildPlugins, t as oxc, u as getChunkName } from "./common.mjs";
-import { t as formatCompatibilityDate } from "../_libs/compatx.mjs";
-import { n as scanHandlers } from "../_chunks/nitro2.mjs";
-import { n as watch } from "../_libs/readdirp+chokidar.mjs";
-import { t as debounce } from "../_libs/perfect-debounce.mjs";
-import { t as alias } from "../_libs/plugin-alias.mjs";
-import { n as inject } from "../_libs/plugin-inject.mjs";
-import { n as generateFSTree } from "../_chunks/utils.mjs";
-import { t as commonjs } from "../_libs/commondir+is-reference.mjs";
-import { t as json } from "../_libs/plugin-json.mjs";
-import { t as nodeResolve } from "../_libs/hasown+resolve+deepmerge.mjs";
+import { NODE_MODULES_RE, baseBuildConfig, baseBuildPlugins, basename, getChunkName, isAbsolute, join, libChunkName, oxc, relative, writeBuildInfo, writeTypes } from "./common.mjs";
+import { formatCompatibilityDate } from "../_libs/compatx.mjs";
+import { scanHandlers } from "../_chunks/nitro.mjs";
+import { watch } from "../_libs/readdirp+chokidar.mjs";
+import { debounce } from "../_libs/perfect-debounce.mjs";
+import { alias } from "../_libs/plugin-alias.mjs";
+import { inject } from "../_libs/plugin-inject.mjs";
+import { generateFSTree } from "../_chunks/utils.mjs";
+import { commonjs } from "../_libs/commondir+is-reference.mjs";
+import { json } from "../_libs/plugin-json.mjs";
+import { nodeResolve } from "../_libs/hasown+resolve+deepmerge.mjs";
 import { defu } from "defu";
 const getRollupConfig = async (nitro) => {
 	const base = baseBuildConfig(nitro);

package/dist/_build/vite.build.mjs

@@ -1,12 +1,12 @@
-import { U as v } from "./common.mjs";
+import { resolveModulePath, v } from "./common.mjs";
 import { nitro } from "nitro/vite";
 async function viteBuild(nitro$1) {
 	if (nitro$1.options.dev) throw new Error("Nitro dev CLI does not supports vite. Please use `vite dev` instead.");
-	const { createBuilder } = await import(nitro$1.options.__vitePkg__ || "vite");
+	const { createBuilder } = await import(resolveModulePath(nitro$1.options.__vitePkg__ || "vite", { from: nitro$1.options.rootDir }));
 	const pluginInstance = nitro({ _nitro: nitro$1 });
 	globalThis.__nitro_build__ = true;
 	const builder = await createBuilder({
-		base: nitro$1.options.rootDir,
+		root: nitro$1.options.rootDir,
 		plugins: [pluginInstance],
 		logLevel: v ? "warn" : void 0
 	});

package/dist/_build/vite.dev.mjs

@@ -0,0 +1,149 @@
+import { join } from "./common.mjs";
+import { scanHandlers } from "../_chunks/nitro.mjs";
+import { watch as watch$1 } from "../_libs/readdirp+chokidar.mjs";
+import { debounce } from "../_libs/perfect-debounce.mjs";
+import { getEnvRunner } from "./vite.env.mjs";
+import { watch } from "node:fs";
+import { withBase } from "ufo";
+import { NodeRequest, sendNodeResponse } from "srvx/node";
+import "node:http";
+import { DevEnvironment } from "vite";
+import { createViteHotChannel } from "env-runner/vite";
+const ASSET_EXT_RE = /^(?:[jt]sx?|mjs|cjs|css|s[ac]ss|less|styl|vue|svelte|astro|mdx?|map|wasm|png|jpe?g|gif|svg|webp|avif|ico|bmp|woff2?|ttf|otf|eot|mp[34]|webm|wav|ogg|m4a)$/i;
+function createFetchableDevEnvironment(name, config, devServer, entry, opts) {
+	return new FetchableDevEnvironment(name, config, {
+		hot: true,
+		transport: createViteHotChannel(devServer, name)
+	}, devServer, entry, opts);
+}
+var FetchableDevEnvironment = class extends DevEnvironment {
+	devServer;
+	#entry;
+	#preventExternalize;
+	constructor(name, config, context, devServer, entry, opts) {
+		super(name, config, context);
+		this.devServer = devServer;
+		this.#entry = entry;
+		this.#preventExternalize = opts?.preventExternalize ?? false;
+	}
+	async fetchModule(id, importer, options) {
+		if (this.#preventExternalize && !id.startsWith("file://") && importer && id[0] !== "." && id[0] !== "/") {
+			const resolved = await this.pluginContainer.resolveId(id, importer);
+			if (resolved && !resolved.external) return super.fetchModule(resolved.id, importer, options);
+		}
+		return super.fetchModule(id, importer, options);
+	}
+	async dispatchFetch(request) {
+		return this.devServer.fetch(request);
+	}
+	async init(...args) {
+		await this.devServer.init?.();
+		await super.init(...args);
+		this.devServer.sendMessage({
+			type: "custom",
+			event: "nitro:vite-env",
+			data: {
+				name: this.name,
+				entry: this.#entry
+			}
+		});
+	}
+};
+async function configureViteDevServer(ctx, server) {
+	const nitro = ctx.nitro;
+	const nitroEnv = server.environments.nitro;
+	const nitroConfigFile = nitro.options._c12.configFile;
+	if (nitroConfigFile) server.config.configFileDependencies.push(nitroConfigFile);
+	if (nitro.options.features.websocket ?? nitro.options.experimental.websocket) server.httpServer.on("upgrade", (req, socket, head) => {
+		if (req.headers["sec-websocket-protocol"]?.startsWith("vite-")) return;
+		getEnvRunner(ctx).upgrade?.({ node: {
+			req,
+			socket,
+			head
+		} });
+	});
+	const reload = debounce(async () => {
+		await scanHandlers(nitro);
+		nitro.routing.sync();
+		nitroEnv.moduleGraph.invalidateAll();
+		nitroEnv.hot.send({ type: "full-reload" });
+	});
+	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 rootDirWatcher = watch(nitro.options.rootDir, { persistent: false }, (_event, filename) => {
+		if (filename && /^server\.[mc]?[jt]sx?$/.test(filename)) reload();
+	});
+	nitro.hooks.hook("close", () => {
+		scanDirsWatcher.close();
+		rootDirWatcher.close();
+	});
+	nitroEnv.devServer.onMessage(async (message) => {
+		if (message?.__rpc === "transformHTML") try {
+			const html = (await server.transformIndexHtml("/", message.data)).replace("<!--ssr-outlet-->", `{{{ globalThis.__nitro_vite_envs__?.["ssr"]?.fetch($REQUEST) || "" }}}`);
+			nitroEnv.devServer.sendMessage({
+				__rpc_id: message.__rpc_id,
+				data: html
+			});
+		} catch (error) {
+			nitroEnv.devServer.sendMessage({
+				__rpc_id: message.__rpc_id,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	});
+	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;
+		const baseURL = nitro.options.baseURL || "/";
+		const originalURL = nodeReq.url;
+		if (baseURL !== "/") nodeReq.url = withBase(nodeReq.url, baseURL);
+		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.dispatchFetch(req);
+			if (nodeRes.writableEnded || nodeRes.headersSent) return;
+			return await sendNodeResponse(nodeRes, envRes);
+		} catch (error) {
+			return next(error);
+		} finally {
+			if (baseURL !== "/") nodeReq.url = originalURL;
+		}
+	};
+	server.middlewares.use(function nitroDevMiddlewarePre(req, res, next) {
+		if (/^\/(?:__|@)/.test(req.url)) return next();
+		const match = nitro.routing.routes.match(req.method || "", new URL(withBase(req.url, nitro.options.baseURL), "http://localhost").pathname);
+		const matchedHandlers = match ? Array.isArray(match) ? match : [match] : [];
+		if (matchedHandlers.some((h) => h?.route && h.route !== "/**" && !h.route.startsWith("/**:"))) return nitroDevMiddleware(req, res, next);
+		res.setHeader("vary", "sec-fetch-dest, accept");
+		const fetchDest = req.headers["sec-fetch-dest"];
+		const ext = req.url.split(/[?#]/, 1)[0].match(/\.([a-z0-9]+)$/i)?.[1];
+		const isAssetByExt = !!ext && ASSET_EXT_RE.test(ext) && !/\btext\/html\b/.test(req.headers["accept"] || "");
+		const isAsset = typeof fetchDest === "string" && fetchDest !== "empty" ? !/^(?:document|iframe|frame)$/.test(fetchDest) : isAssetByExt;
+		if (!isAsset && (matchedHandlers.length > 0 || !ext)) return nitroDevMiddleware(req, res, next);
+		if (isAsset) req._nitroHandled = true;
+		next();
+	});
+	return () => {
+		server.middlewares.use(nitroDevMiddleware);
+	};
+}
+export { configureViteDevServer, createFetchableDevEnvironment };