nitro-nightly 3.1.0-20251029-083418-84ceb86e → 3.1.0-20251029-124449-782162a4

package/dist/_build/info.mjs

@@ -291,7 +291,6 @@ import * as __routeRules__ from "nitro/runtime/internal/route-rules";
 ${nitro.options.serverEntry ? `import __serverEntry__ from ${JSON.stringify(nitro.options.serverEntry)};` : ""}
 import {${h3Imports.join(", ")}} from "nitro/deps/h3";
 
-export const hasRouteRules = ${nitro.routing.routeRules.hasRoutes() ? "true" : "false"};
 export const findRouteRules = ${nitro.routing.routeRules.compileToString({ serialize: serializeRouteRule, matchAll: true })}
 
 ${allHandlers.filter((h) => !h.lazy).map((h) => (
@@ -306,13 +305,10 @@ ${allHandlers.filter((h) => h.lazy).map(
             )
           ).join("\n")}
 
-export const hasRoutes = ${nitro.routing.routes.hasRoutes() ? "true" : "false"};
 export const findRoute = ${nitro.routing.routes.compileToString({ serialize: serializeHandler })}
 
-export const hasRoutedMiddleware = ${nitro.routing.routedMiddleware.hasRoutes() ? "true" : "false"};
 export const findRoutedMiddleware = ${nitro.routing.routedMiddleware.compileToString({ serialize: serializeHandler, matchAll: true })};
 
-export const hasGlobalMiddleware = ${nitro.routing.globalMiddleware.length > 0 || nitro.options.serverEntry ? "true" : "false"};
 export const globalMiddleware = [
   ${nitro.routing.globalMiddleware.map((h) => h.lazy ? h._importHash : `toEventHandler(${h._importHash})`).join(",")}
   ${nitro.options.serverEntry ? `,toMiddleware(__serverEntry__)` : ""}
@@ -827,6 +823,35 @@ function rendererTemplate(nitro) {
   );
 }
 
+function featureFlags(nitro) {
+  return virtual(
+    {
+      "#nitro-internal-virtual/feature-flags": () => {
+        const featureFlags2 = {
+          // Routing
+          hasRoutes: nitro.routing.routes.hasRoutes(),
+          hasRouteRules: nitro.routing.routeRules.hasRoutes(),
+          hasRoutedMiddleware: nitro.routing.routedMiddleware.hasRoutes(),
+          hasGlobalMiddleware: nitro.routing.globalMiddleware.length > 0 || !!nitro.options.serverEntry,
+          // Plugins
+          hasPlugins: nitro.options.plugins.length > 0,
+          hasHooks: nitro.options.features?.runtimeHooks ?? nitro.options.plugins.length > 0
+        };
+        return (
+          /* js */
+          Object.entries(featureFlags2).map(
+            ([key, value]) => (
+              /* js */
+              `export const ${key} = ${Boolean(value)};`
+            )
+          ).join("\n")
+        );
+      }
+    },
+    nitro.vfs
+  );
+}
+
 function baseBuildPlugins(nitro, base) {
   const plugins = [];
   if (nitro.options.imports) {
@@ -856,6 +881,7 @@ function baseBuildPlugins(nitro, base) {
       nitro.vfs
     )
   );
+  plugins.push(featureFlags(nitro));
   plugins.push(serverAssets(nitro));
   plugins.push(publicAssets(nitro));
   plugins.push(storage(nitro));

package/dist/_build/vite.mjs

@@ -738,7 +738,9 @@ function nitroMain(ctx) {
           sharedConfigBuild: true
         },
         server: {
-          port: Number.parseInt(process.env.PORT || "") || userConfig.server?.port || useNitro(ctx).options.devServer?.port || 3e3
+          port: Number.parseInt(process.env.PORT || "") || userConfig.server?.port || useNitro(ctx).options.devServer?.port || 3e3,
+          // #3673, disable Vite's `cors` by default as Nitro handles all requests
+          cors: false
         }
       };
     },

package/dist/presets/_nitro/runtime/nitro-dev.mjs

@@ -1,5 +1,5 @@
 import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+import { useNitroApp, useNitroHooks } from "nitro/runtime";
 import { trapUnhandledNodeErrors } from "nitro/runtime/internal";
 import { startScheduleRunner } from "nitro/runtime/internal";
 import { Server } from "node:http";
@@ -18,6 +18,7 @@ parentPort?.on("message", (msg) => {
   }
 });
 const nitroApp = useNitroApp();
+const nitroHooks = useNitroHooks();
 const server = new Server(toNodeHandler(nitroApp.fetch));
 let listener;
 listen().catch((error) => {
@@ -56,7 +57,7 @@ async function shutdown() {
   server.closeAllConnections?.();
   await Promise.all([
     new Promise((resolve) => listener?.close(resolve)),
-    nitroApp.hooks.callHook("close").catch(console.error)
+    nitroHooks.callHook("close").catch(console.error)
   ]);
   parentPort?.postMessage({ event: "exit" });
 }

package/dist/presets/_nitro/runtime/nitro-prerenderer.mjs

@@ -1,11 +1,12 @@
 import "#nitro-internal-pollyfills";
 import consola from "consola";
-import { useNitroApp } from "nitro/runtime";
+import { useNitroApp, useNitroHooks } from "nitro/runtime";
 import { trapUnhandledNodeErrors } from "nitro/runtime/internal";
 const nitroApp = useNitroApp();
+const nitroHooks = useNitroHooks();
 export const appFetch = nitroApp.fetch;
-export const closePrerenderer = () => nitroApp.hooks.callHook("close");
-nitroApp.hooks.hook("error", (error, context) => {
+export const closePrerenderer = () => nitroHooks.callHook("close");
+nitroHooks.hook("error", (error, context) => {
   if (!error.unhandled && error.status >= 500 && context.event?.req?.headers instanceof Headers && context.event.req.headers.get("x-nitro-prerender")) {
     consola.error(
       `[prerender error]`,

package/dist/presets/cloudflare/runtime/_module-handler.mjs

@@ -1,8 +1,9 @@
 import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
+import { useNitroApp, useNitroHooks } from "nitro/runtime";
 import { runCronTasks } from "nitro/runtime/internal";
 export function createHandler(hooks) {
   const nitroApp = useNitroApp();
+  const nitroHooks = useNitroHooks();
   return {
     async fetch(request, env, context) {
       const ctxExt = {};
@@ -18,7 +19,7 @@ export function createHandler(hooks) {
     scheduled(controller, env, context) {
       globalThis.__env__ = env;
       context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:scheduled", {
+        nitroHooks.callHook("cloudflare:scheduled", {
           controller,
           env,
           context
@@ -41,7 +42,7 @@ export function createHandler(hooks) {
     email(message, env, context) {
       globalThis.__env__ = env;
       context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:email", {
+        nitroHooks.callHook("cloudflare:email", {
           message,
           event: message,
           // backward compat
@@ -53,7 +54,7 @@ export function createHandler(hooks) {
     queue(batch, env, context) {
       globalThis.__env__ = env;
       context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:queue", {
+        nitroHooks.callHook("cloudflare:queue", {
           batch,
           event: batch,
           env,
@@ -64,7 +65,7 @@ export function createHandler(hooks) {
     tail(traces, env, context) {
       globalThis.__env__ = env;
       context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:tail", {
+        nitroHooks.callHook("cloudflare:tail", {
           traces,
           env,
           context
@@ -74,7 +75,7 @@ export function createHandler(hooks) {
     trace(traces, env, context) {
       globalThis.__env__ = env;
       context.waitUntil(
-        nitroApp.hooks.callHook("cloudflare:trace", {
+        nitroHooks.callHook("cloudflare:trace", {
           traces,
           env,
           context

package/dist/presets/cloudflare/runtime/cloudflare-durable.mjs

@@ -1,12 +1,13 @@
 import "#nitro-internal-pollyfills";
 import { DurableObject } from "cloudflare:workers";
 import wsAdapter from "crossws/adapters/cloudflare";
-import { useNitroApp } from "nitro/runtime";
+import { useNitroApp, useNitroHooks } from "nitro/runtime";
 import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
 import { createHandler, fetchHandler } from "./_module-handler.mjs";
 const DURABLE_BINDING = "$DurableObject";
 const DURABLE_INSTANCE = "server";
 const nitroApp = useNitroApp();
+const nitroHooks = useNitroHooks();
 const getDurableStub = (env) => {
   const binding = env[DURABLE_BINDING];
   if (!binding) {
@@ -38,7 +39,7 @@ export class $DurableObject extends DurableObject {
   constructor(state, env) {
     super(state, env);
     state.waitUntil(
-      nitroApp.hooks.callHook("cloudflare:durable:init", this, {
+      nitroHooks.callHook("cloudflare:durable:init", this, {
         state,
         env
       })
@@ -57,9 +58,7 @@ export class $DurableObject extends DurableObject {
     });
   }
   alarm() {
-    this.ctx.waitUntil(
-      nitroApp.hooks.callHook("cloudflare:durable:alarm", this)
-    );
+    this.ctx.waitUntil(nitroHooks.callHook("cloudflare:durable:alarm", this));
   }
   async webSocketMessage(client, message) {
     if (import.meta._websocket) {

package/dist/presets/node/runtime/node-server.mjs

@@ -33,7 +33,7 @@ const listener = server.listen(path ? { path } : { port, host }, (err) => {
   console.log(`Listening on ${url}`);
 });
 trapUnhandledNodeErrors();
-setupGracefulShutdown(listener, nitroApp);
+setupGracefulShutdown(listener);
 if (import.meta._websocket) {
   const { handleUpgrade } = wsAdapter(nitroApp.h3App.websocket);
   server.on("upgrade", handleUpgrade);

package/dist/runtime/index.d.mts

@@ -5,7 +5,7 @@ export { useRuntimeConfig } from "./internal/runtime-config.mjs";
 export { useRequest } from "./internal/context.mjs";
 export { defineRenderHandler } from "./internal/renderer.mjs";
 export { defineCachedFunction, defineCachedEventHandler, defineCachedHandler, cachedFunction, cachedEventHandler, } from "./internal/cache.mjs";
-export { useNitroApp } from "./internal/app.mjs";
+export { useNitroApp, useNitroHooks } from "./internal/app.mjs";
 export { useStorage } from "./internal/storage.mjs";
 export { useDatabase } from "./internal/database.mjs";
 export { defineTask, runTask } from "./internal/task.mjs";

package/dist/runtime/index.mjs

@@ -11,7 +11,7 @@ export {
   cachedFunction,
   cachedEventHandler
 } from "./internal/cache.mjs";
-export { useNitroApp } from "./internal/app.mjs";
+export { useNitroApp, useNitroHooks } from "./internal/app.mjs";
 export { useStorage } from "./internal/storage.mjs";
 export { useDatabase } from "./internal/database.mjs";
 export { defineTask, runTask } from "./internal/task.mjs";

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

@@ -1,2 +1,4 @@
-import type { NitroApp } from "nitro/types";
+import type { NitroApp, NitroRuntimeHooks } from "nitro/types";
+import { HookableCore } from "hookable";
 export declare function useNitroApp(): NitroApp;
+export declare function useNitroHooks(): HookableCore<NitroRuntimeHooks>;

package/dist/runtime/internal/app.mjs

@@ -4,34 +4,48 @@ import { nitroAsyncContext } from "./context.mjs";
 import errorHandler from "#nitro-internal-virtual/error-handler";
 import { plugins } from "#nitro-internal-virtual/plugins";
 import {
-  hasRouteRules,
   findRoute,
   findRouteRules,
   globalMiddleware,
-  findRoutedMiddleware,
+  findRoutedMiddleware
+} from "#nitro-internal-virtual/routing";
+import {
+  hasRouteRules,
   hasRoutedMiddleware,
   hasGlobalMiddleware,
-  hasRoutes
-} from "#nitro-internal-virtual/routing";
+  hasRoutes,
+  hasHooks,
+  hasPlugins
+} from "#nitro-internal-virtual/feature-flags";
 export function useNitroApp() {
   return useNitroApp.__instance__ ??= initNitroApp();
 }
+export function useNitroHooks() {
+  const nitroApp = useNitroApp();
+  const hooks = nitroApp.hooks;
+  if (hooks) {
+    return hooks;
+  }
+  return nitroApp.hooks = new HookableCore();
+}
 function initNitroApp() {
   const nitroApp = createNitroApp();
-  for (const plugin of plugins) {
-    try {
-      plugin(nitroApp);
-    } catch (error) {
-      nitroApp.captureError(error, { tags: ["plugin"] });
-      throw error;
+  if (hasPlugins) {
+    for (const plugin of plugins) {
+      try {
+        plugin(nitroApp);
+      } catch (error) {
+        nitroApp.captureError(error, { tags: ["plugin"] });
+        throw error;
+      }
     }
   }
   return nitroApp;
 }
 function createNitroApp() {
-  const hooks = new HookableCore();
+  const hooks = hasHooks ? new HookableCore() : void 0;
   const captureError = (error, errorCtx) => {
-    const promise = hooks.callHook("error", error, errorCtx)?.catch?.((hookError) => {
+    const promise = hasHooks && hooks.callHook("error", error, errorCtx)?.catch?.((hookError) => {
       console.error("Error while capturing another error", hookError);
     });
     if (errorCtx?.event) {
@@ -39,62 +53,60 @@ function createNitroApp() {
       if (errors) {
         errors.push({ error, context: errorCtx });
       }
-      if (typeof errorCtx.event.req.waitUntil === "function") {
+      if (hasHooks && typeof errorCtx.event.req.waitUntil === "function") {
         errorCtx.event.req.waitUntil(promise);
       }
     }
   };
   const h3App = createH3App({
     onError(error, event) {
-      captureError(error, { event });
+      hasHooks && captureError(error, { event });
       return errorHandler(error, event);
-    },
-    onRequest(event) {
+    }
+  });
+  if (hasHooks) {
+    h3App.config.onRequest = (event) => {
       return hooks.callHook("request", event)?.catch?.((error) => {
         captureError(error, { event, tags: ["request"] });
       });
-    },
-    onResponse(res, event) {
+    };
+    h3App.config.onResponse = (res, event) => {
       return hooks.callHook("response", res, event)?.catch?.((error) => {
         captureError(error, { event, tags: ["response"] });
       });
-    }
-  });
-  let fetchHandler = (req) => {
-    req.context ??= {};
+    };
+  }
+  let appReqHandler = (req) => {
+    req.context ||= {};
     req.context.nitro = req.context.nitro || { errors: [] };
     return h3App.fetch(req);
   };
   if (import.meta._asyncContext) {
-    const originalFetchHandler = fetchHandler;
-    fetchHandler = (req) => {
+    const originalHandler = appReqHandler;
+    appReqHandler = (req) => {
       const asyncCtx = { request: req };
-      return nitroAsyncContext.callAsync(
-        asyncCtx,
-        () => originalFetchHandler(req)
-      );
+      return nitroAsyncContext.callAsync(asyncCtx, () => originalHandler(req));
     };
   }
-  const requestHandler = (input, init, context) => {
+  const appFetchHandler = (input, init, context) => {
     const req = toRequest(input, init);
     req.context = { ...req.context, ...context };
-    return Promise.resolve(fetchHandler(req));
+    return Promise.resolve(appReqHandler(req));
   };
-  const originalFetch = globalThis.fetch;
-  const nitroFetch = (input, init) => {
-    if (typeof input === "string" && input.startsWith("/")) {
-      return requestHandler(input, init);
+  const nativeFetch = globalThis.fetch;
+  globalThis.fetch = (input, init) => {
+    if (typeof input === "string" && input.charCodeAt(0) === 47) {
+      return appFetchHandler(input, init);
     }
-    if (input instanceof Request && "_request" in input) {
+    if ("_request" in input) {
       input = input._request;
     }
-    return originalFetch(input, init);
+    return nativeFetch(input, init);
   };
-  globalThis.fetch = nitroFetch;
   const app = {
+    fetch: appFetchHandler,
     _h3: h3App,
     hooks,
-    fetch: requestHandler,
     captureError
   };
   return app;

package/dist/runtime/internal/renderer.mjs

@@ -1,12 +1,12 @@
 import { defineHandler } from "h3";
-import { useNitroApp } from "./app.mjs";
+import { useNitroHooks } from "./app.mjs";
 import { useRuntimeConfig } from "./runtime-config.mjs";
 export function defineRenderHandler(render) {
   const runtimeConfig = useRuntimeConfig();
   return defineHandler(async (event) => {
-    const nitroApp = useNitroApp();
+    const nitroHooks = useNitroHooks();
     const ctx = { event, render, response: void 0 };
-    await nitroApp.hooks.callHook("render:before", ctx);
+    await nitroHooks.callHook("render:before", ctx);
     if (!ctx.response) {
       if (event.url.pathname === `${runtimeConfig.app.baseURL}favicon.ico`) {
         event.res.headers.set("Content-Type", "image/x-icon");
@@ -21,7 +21,7 @@ export function defineRenderHandler(render) {
         return "No response returned from render handler: " + event.url.pathname;
       }
     }
-    await nitroApp.hooks.callHook("render:response", ctx.response, ctx);
+    await nitroHooks.callHook("render:response", ctx.response, ctx);
     if (ctx.response.headers) {
       for (const [key, value] of Object.entries(ctx.response.headers)) {
         event.res.headers.set(key, value);

package/dist/runtime/internal/shutdown.d.mts

@@ -1,9 +1,8 @@
 import type { Server as HttpServer } from "node:http";
-import type { NitroApp } from "nitro/types";
 export declare function getGracefulShutdownConfig(): {
     disabled: boolean;
     signals: string[];
     timeout: number;
     forceExit: boolean;
 };
-export declare function setupGracefulShutdown(listener: HttpServer, nitroApp: NitroApp): void;
+export declare function setupGracefulShutdown(listener: HttpServer): void;

package/dist/runtime/internal/shutdown.mjs

@@ -1,4 +1,5 @@
 import gracefulShutdown from "./lib/http-graceful-shutdown.mjs";
+import { useNitroHooks } from "./app.mjs";
 export function getGracefulShutdownConfig() {
   return {
     disabled: !!process.env.NITRO_SHUTDOWN_DISABLED,
@@ -7,7 +8,7 @@ export function getGracefulShutdownConfig() {
     forceExit: !process.env.NITRO_SHUTDOWN_NO_FORCE_EXIT
   };
 }
-export function setupGracefulShutdown(listener, nitroApp) {
+export function setupGracefulShutdown(listener) {
   const shutdownConfig = getGracefulShutdownConfig();
   if (shutdownConfig.disabled) {
     return;
@@ -22,7 +23,7 @@ export function setupGracefulShutdown(listener, nitroApp) {
           console.warn("Graceful shutdown timeout, force exiting...");
           resolve();
         }, shutdownConfig.timeout);
-        Promise.resolve(nitroApp.hooks.callHook("close")).catch((error) => {
+        Promise.resolve(useNitroHooks().callHook("close")).catch((error) => {
           console.error(error);
         }).finally(() => {
           clearTimeout(timeout);

package/dist/types/index.d.mts

@@ -146,12 +146,14 @@ interface CachedEventHandlerOptions extends Omit<CacheOptions<ResponseCacheEntry
 
 interface NitroApp {
     _h3?: H3Core;
-    hooks: HookableCore<NitroRuntimeHooks>;
-    fetch: (req: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext) => Promise<Response>;
+    hooks?: HookableCore<NitroRuntimeHooks>;
     captureError: CaptureError;
+    fetch: (req: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext) => Promise<Response>;
 }
 interface NitroAppPlugin {
-    (nitro: NitroApp): void;
+    (nitro: NitroApp & {
+        hooks: NonNullable<NitroApp["hooks"]>;
+    }): void;
 }
 interface NitroAsyncContext {
     request: ServerRequest;
@@ -4118,6 +4120,14 @@ interface NitroOptions extends PresetOptions {
     ssrRoutes: string[];
     serveStatic: boolean | "node" | "deno" | "inline";
     noPublicDir: boolean;
+    features: {
+        /**
+         * Enable runtime hooks for request and response.
+         *
+         * By default this feature will be enabled if there is at least one nitro plugin.
+         */
+        runtimeHooks: boolean;
+    };
     /**
      * @experimental Requires `experimental.wasm` to work
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitro-nightly",
-  "version": "3.1.0-20251029-083418-84ceb86e",
+  "version": "3.1.0-20251029-124449-782162a4",
   "description": "Build and Deploy Universal JavaScript Servers",
   "homepage": "https://nitro.build",
   "repository": "nitrojs/nitro",