nitro 3.0.260429-beta → 3.0.260522-beta

package/dist/cli/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as runMain, t as defineCommand } from "../_libs/citty.mjs";
+import { defineCommand, runMain } from "../_libs/citty.mjs";
 import { version } from "nitro/meta";
 runMain(defineCommand({
 	meta: {

package/dist/docs/1.deploy/2.providers/2.aws-amplify.md

@@ -31,7 +31,7 @@ export default defineConfig({
       // catchAllStaticFallback: true,
       // imageOptimization: { path: "/_image", cacheControl: "public, max-age=3600, immutable" },
       // imageSettings: { ... },
-      // runtime: "nodejs18.x", // default: "nodejs18.x" | "nodejs16.x" | "nodejs20.x"
+      // runtime: "nodejs24.x", // default: "nodejs20.x" | "nodejs22.x" | "nodejs24.x"
   }
 })
 ```
@@ -48,7 +48,7 @@ frontend:
   phases:
     preBuild:
       commands:
-        - nvm use 18 && node --version
+        - nvm use 24 && node --version
         - corepack enable && npx --yes nypm install
     build:
       commands:
@@ -66,7 +66,7 @@ applications:
       phases:
         preBuild:
           commands:
-          - nvm use 18 && node --version
+          - nvm use 24 && node --version
           - corepack enable && npx --yes nypm install
         build:
           commands:

package/dist/docs/1.deploy/2.providers/21.vercel.md

@@ -210,6 +210,12 @@ export default defineEventHandler(async (event) => {
 });
 ```
 
+### Local development
+
+Queues work in `nitro dev` — `send()` delivers messages straight to your `vercel:queue` hook, so you can iterate without deploying. Pull your Vercel environment first with `vercel link` and `vercel env pull` so the SDK can authenticate.
+
+If your hook throws, the message is retried locally. Retries honour `retryAfterSeconds` from each trigger when set.
+
 ## Custom build output configuration
 
 You can provide additional [build output configuration](https://vercel.com/docs/build-output-api/v3) using `vercel.config` key inside `nitro.config`. It will be merged with built-in auto-generated config.

package/dist/docs/3.examples/27.vite-ssr-tsr-react.md

@@ -50,7 +50,7 @@
     "baseUrl": ".",
     "jsx": "react-jsx",
     "paths": {
-      "@/*": ["sec/*"]
+      "@/*": ["./src/*"]
     }
   }
 }

package/dist/presets/vercel/runtime/queue.dev.mjs

@@ -0,0 +1,41 @@
+import { send } from "@vercel/queue";
+import { useRuntimeConfig } from "nitro/runtime-config";
+import { registerVercelQueueConsumer } from "env-runner/runners/vercel/queue-dev";
+const queueDevPlugin = (nitroApp) => {
+	const triggers = useRuntimeConfig().vercel?.queues?.triggers || [];
+	if (triggers.length === 0) {
+		return;
+	}
+	const unregisters = [];
+	const ready = Promise.all(triggers.map((trigger) => registerVercelQueueConsumer({
+		topic: trigger.topic,
+		retryAfterSeconds: trigger.retryAfterSeconds,
+		handler: async (message, metadata) => {
+			try {
+				await nitroApp.hooks.callHook("vercel:queue", {
+					message,
+					metadata,
+					send
+				});
+			} catch (error) {
+				console.error("[vercel:queue]", error);
+				nitroApp.captureError?.(error, { tags: ["vercel:queue"] });
+				
+				throw error;
+			}
+		}
+	}).then((unregister) => {
+		unregisters.push(unregister);
+	}))).catch((error) => {
+		console.error("[vercel:queue] failed to register dev consumer:", error);
+	});
+	nitroApp.hooks.hook("close", async () => {
+		await ready;
+		for (const unregister of unregisters) {
+			try {
+				unregister();
+			} catch {}
+		}
+	});
+};
+export default queueDevPlugin;

package/dist/runtime/internal/app.mjs

@@ -1,11 +1,8 @@
-import { H3Core, toRequest } from "h3";
+import { toRequest } from "h3";
 import { HookableCore } from "hookable";
-import { nitroAsyncContext } from "./context.mjs";
 
-import errorHandler from "#nitro/virtual/error-handler";
-import { plugins } from "#nitro/virtual/plugins";
-import { findRoute, findRouteRules, globalMiddleware, findRoutedMiddleware } from "#nitro/virtual/routing";
-import { hasRouteRules, hasRoutedMiddleware, hasGlobalMiddleware, hasRoutes, hasHooks, hasPlugins } from "#nitro/virtual/feature-flags";
+import { findRouteRules } from "#nitro/virtual/routing";
+import { createNitroApp, initNitroPlugins } from "#nitro/virtual/app";
 const APP_ID = import.meta.prerender ? "prerender" : "default";
 export function useNitroApp() {
 	let instance = useNitroApp._instance;
@@ -15,9 +12,7 @@ export function useNitroApp() {
 	instance = useNitroApp._instance = createNitroApp();
 	globalThis.__nitro__ = globalThis.__nitro__ || {};
 	globalThis.__nitro__[APP_ID] = instance;
-	if (hasPlugins) {
-		initNitroPlugins(instance);
-	}
+	initNitroPlugins(instance);
 	return instance;
 }
 export function useNitroHooks() {
@@ -53,108 +48,6 @@ export function fetch(resource, init, context) {
 	resource = resource._request || resource;
 	return globalThis.fetch(resource, init);
 }
-function createNitroApp() {
-	const hooks = hasHooks ? new HookableCore() : undefined;
-	const captureError = (error, errorCtx) => {
-		const promise = hasHooks && hooks.callHook("error", error, errorCtx)?.catch?.((hookError) => {
-			console.error("Error while capturing another error", hookError);
-		});
-		if (errorCtx?.event) {
-			const errors = errorCtx.event.req.context?.nitro?.errors;
-			if (errors) {
-				errors.push({
-					error,
-					context: errorCtx
-				});
-			}
-			if (hasHooks && promise && typeof errorCtx.event.req.waitUntil === "function") {
-				errorCtx.event.req.waitUntil(promise);
-			}
-		}
-	};
-	const h3App = createH3App({ onError(error, event) {
-		hasHooks && captureError(error, { event });
-		return errorHandler(error, event);
-	} });
-	if (hasHooks) {
-		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"]
-				});
-			});
-		};
-	}
-	let appHandler = (req) => {
-		req.context ||= {};
-		req.context.nitro = req.context.nitro || { errors: [] };
-		return h3App.fetch(req);
-	};
-	
-	if (import.meta._asyncContext) {
-		const originalHandler = appHandler;
-		appHandler = (req) => {
-			const asyncCtx = { request: req };
-			return nitroAsyncContext.callAsync(asyncCtx, () => originalHandler(req));
-		};
-	}
-	const app = {
-		fetch: appHandler,
-		h3: h3App,
-		hooks,
-		captureError
-	};
-	return app;
-}
-function initNitroPlugins(app) {
-	for (const plugin of plugins) {
-		try {
-			plugin(app);
-		} catch (error) {
-			app.captureError?.(error, { tags: ["plugin"] });
-			throw error;
-		}
-	}
-	return app;
-}
-function createH3App(config) {
-	
-	const h3App = new H3Core(config);
-	
-	hasRoutes && (h3App["~findRoute"] = (event) => findRoute(event.req.method, event.url.pathname));
-	hasGlobalMiddleware && h3App["~middleware"].push(...globalMiddleware);
-	if (hasRouteRules || hasRoutedMiddleware) {
-		h3App["~getMiddleware"] = (event, route) => {
-			const needsRouting = hasRouteRules || hasRoutedMiddleware;
-			const pathname = needsRouting ? event.url.pathname : undefined;
-			const method = needsRouting ? event.req.method : undefined;
-			const middleware = [];
-			if (hasRouteRules) {
-				const routeRules = getRouteRules(method, pathname);
-				event.context.routeRules = routeRules?.routeRules;
-				if (routeRules?.routeRuleMiddleware.length) {
-					middleware.push(...routeRules.routeRuleMiddleware);
-				}
-			}
-			hasGlobalMiddleware && middleware.push(...h3App["~middleware"]);
-			hasRoutedMiddleware && middleware.push(...findRoutedMiddleware(method, pathname).map((r) => r.data));
-			if (hasRoutes && route?.data?.middleware?.length) {
-				middleware.push(...route.data.middleware);
-			}
-			return middleware;
-		};
-	}
-	return h3App;
-}
 export function getRouteRules(method, pathname) {
 	const m = findRouteRules(method, pathname);
 	if (!m?.length) {

package/dist/runtime/virtual/app.d.mts

@@ -0,0 +1,4 @@
+import "./_runtime_warn.mjs";
+import type { NitroApp } from "nitro/types";
+export declare function createNitroApp(): NitroApp;
+export declare function initNitroPlugins(app: NitroApp): NitroApp;

package/dist/runtime/virtual/app.mjs

@@ -0,0 +1,32 @@
+import "./_runtime_warn.mjs";
+import { H3Core } from "h3";
+import errorHandler from "#nitro/virtual/error-handler";
+export function createNitroApp() {
+	const h3App = new H3Core({ onError(error, event) {
+		return errorHandler(error, event);
+	} });
+	const captureError = (error, errorCtx) => {
+		if (errorCtx?.event) {
+			const errors = errorCtx.event.req.context?.nitro?.errors;
+			if (errors) {
+				errors.push({
+					error,
+					context: errorCtx
+				});
+			}
+		}
+	};
+	return {
+		fetch: (req) => {
+			req.context ||= {};
+			req.context.nitro = req.context.nitro || { errors: [] };
+			return h3App.fetch(req);
+		},
+		h3: h3App,
+		hooks: undefined,
+		captureError
+	};
+}
+export function initNitroPlugins(app) {
+	return app;
+}