nitro-nightly 3.1.0-20251026-232057-ce388de2 → 3.1.0-20251027-223403-81bd673d

package/dist/_chunks/info.mjs

@@ -10350,7 +10350,8 @@ function routing(nitro) {
           "_importHash"
         );
         const h3Imports = [
-          (nitro.options.serverEntry || allHandlers.some((h) => !h.lazy)) && "toEventHandler",
+          allHandlers.some((h) => !h.lazy) && "toEventHandler",
+          nitro.options.serverEntry && "toMiddleware",
           allHandlers.some((h) => h.lazy) && "defineLazyEventHandler"
         ].filter(Boolean);
         return (
@@ -10382,11 +10383,10 @@ export const hasRoutedMiddleware = ${nitro.routing.routedMiddleware.hasRoutes()
 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 && /* js */
-          `const serverEntry = toEventHandler(__serverEntry__);
-if (serverEntry) { globalMiddleware.push(serverEntry) }`}
+export const globalMiddleware = [
+  ${nitro.routing.globalMiddleware.map((h) => h.lazy ? h._importHash : `toEventHandler(${h._importHash})`).join(",")}
+  ${nitro.options.serverEntry ? `,toMiddleware(__serverEntry__)` : ""}
+].filter(Boolean);
   `
         );
       },

package/dist/presets/standard/runtime/server.d.mts

@@ -1,5 +1,5 @@
 import "#nitro-internal-pollyfills";
 declare const _default: {
-    fetch: any;
+    fetch: (req: Request) => any;
 };
 export default _default;

package/dist/presets/standard/runtime/server.mjs

@@ -2,5 +2,5 @@ import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
 const nitroApp = useNitroApp();
 export default {
-  fetch: nitroApp.fetch
+  fetch: (req) => nitroApp.fetch(req)
 };

package/dist/runtime/internal/app.mjs

@@ -63,7 +63,7 @@ function createNitroApp() {
   let fetchHandler = (req) => {
     req.context ??= {};
     req.context.nitro = req.context.nitro || { errors: [] };
-    return h3App.request(req, void 0, req.context);
+    return h3App.fetch(req);
   };
   if (import.meta._asyncContext) {
     const originalFetchHandler = fetchHandler;
@@ -101,34 +101,31 @@ function createNitroApp() {
 }
 function createH3App(config) {
   const h3App = new H3Core(config);
-  if (hasRoutes) {
-    h3App._findRoute = (event) => findRoute(event.req.method, event.url.pathname);
-  }
-  h3App._getMiddleware = (event, route) => {
-    const needsRouting = hasRouteRules || hasRoutedMiddleware;
-    const pathname = needsRouting ? event.url.pathname : void 0;
-    const method = needsRouting ? event.req.method : void 0;
-    const middleware = [];
-    if (hasRouteRules) {
-      const routeRules = getRouteRules(method, pathname);
-      event.context.routeRules = routeRules?.routeRules;
-      if (routeRules?.routeRuleMiddleware.length) {
-        middleware.push(...routeRules.routeRuleMiddleware);
+  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 : void 0;
+      const method = needsRouting ? event.req.method : void 0;
+      const middleware = [];
+      if (hasRouteRules) {
+        const routeRules = getRouteRules(method, pathname);
+        event.context.routeRules = routeRules?.routeRules;
+        if (routeRules?.routeRuleMiddleware.length) {
+          middleware.push(...routeRules.routeRuleMiddleware);
+        }
       }
-    }
-    if (hasGlobalMiddleware) {
-      middleware.push(...globalMiddleware);
-    }
-    if (hasRoutedMiddleware) {
-      middleware.push(
+      hasGlobalMiddleware && middleware.push(...h3App["~middleware"]);
+      hasRoutedMiddleware && middleware.push(
         ...findRoutedMiddleware(method, pathname).map((r) => r.data)
       );
-    }
-    if (route?.data?.middleware?.length) {
-      middleware.push(...route.data.middleware);
-    }
-    return middleware;
-  };
+      if (hasRoutes && route?.data?.middleware?.length) {
+        middleware.push(...route.data.middleware);
+      }
+      return middleware;
+    };
+  }
   return h3App;
 }
 function getRouteRules(method, pathname) {

package/dist/runtime/internal/error/prod.d.mts

@@ -1,7 +1,8 @@
 import type { HTTPError, HTTPEvent } from "h3";
 import type { InternalHandlerResponse } from "./utils.mjs";
-declare const _default: NitroErrorHandler;
-export default _default;
+import type { NitroErrorHandler } from "nitro/types";
+declare const errorHandler: NitroErrorHandler;
+export default errorHandler;
 export declare function defaultHandler(error: HTTPError, event: HTTPEvent, opts?: {
     silent?: boolean;
     json?: boolean;

package/dist/runtime/internal/error/prod.mjs

@@ -1,16 +1,16 @@
-import { getRequestURL } from "h3";
-import { defineNitroErrorHandler } from "./utils.mjs";
 import { FastResponse } from "srvx";
-export default defineNitroErrorHandler(
-  function defaultNitroErrorHandler(error, event) {
-    const res = defaultHandler(error, event);
-    return new FastResponse(JSON.stringify(res.body, null, 2), res);
-  }
-);
+const errorHandler = (error, event) => {
+  const res = defaultHandler(error, event);
+  return new FastResponse(
+    typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2),
+    res
+  );
+};
+export default errorHandler;
 export function defaultHandler(error, event, opts) {
   const isSensitive = error.unhandled;
   const status = error.status || 500;
-  const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true });
+  const url = event.url || new URL(event.req.url);
   if (status === 404) {
     const baseURL = import.meta.baseURL || "/";
     if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) {
@@ -33,13 +33,9 @@ export function defaultHandler(error, event, opts) {
   }
   const headers = {
     "content-type": "application/json",
-    // Prevent browser from guessing the MIME types of resources.
     "x-content-type-options": "nosniff",
-    // Prevent error page from being embedded in an iframe
     "x-frame-options": "DENY",
-    // Prevent browsers from sending the Referer header
     "referrer-policy": "no-referrer",
-    // Disable the execution of any js
     "content-security-policy": "script-src 'none'; frame-ancestors 'none';"
   };
   if (status === 404 || !event.res.headers.has("cache-control")) {

package/dist/runtime/internal/routes/dev-tasks.d.mts

@@ -1,3 +1,31 @@
-import { H3 } from "h3";
-declare const _default: H3;
+declare const _default: {
+    "~rou3": import("h3").RouterContext;
+    request(request: import("srvx").ServerRequest | URL | string, options?: RequestInit, context?: import("h3").H3EventContext): Response | Promise<Response>;
+    use(route: string, handler: import("h3").Middleware, opts?: import("h3").MiddlewareOptions): /*elided*/ any;
+    use(handler: import("h3").Middleware, opts?: import("h3").MiddlewareOptions): /*elided*/ any;
+    on(method: import("h3").HTTPMethod | Lowercase<import("h3").HTTPMethod> | "", route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    register(plugin: import("h3").H3Plugin): /*elided*/ any;
+    mount(base: string, input: import("srvx").FetchHandler | {
+        fetch: import("srvx").FetchHandler;
+    } | /*elided*/ any): /*elided*/ any;
+    all(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    get(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    post(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    put(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    delete(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    patch(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    head(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    options(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    connect(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    trace(route: string, handler: import("h3").HTTPHandler, opts?: import("h3").RouteOptions): /*elided*/ any;
+    readonly config: import("h3").H3Config;
+    "~middleware": import("h3").Middleware[];
+    "~routes": import("h3").H3Route[];
+    fetch(_request: import("srvx").ServerRequest): Response | Promise<Response>;
+    handler(event: import("h3").H3Event): unknown | Promise<unknown>;
+    "~request"(request: import("srvx").ServerRequest, context?: import("h3").H3EventContext): Response | Promise<Response>;
+    "~findRoute"(_event: import("h3").H3Event): import("h3").MatchedRoute<import("h3").H3Route> | void;
+    "~getMiddleware"(event: import("h3").H3Event, route: import("h3").MatchedRoute<import("h3").H3Route> | undefined): import("h3").Middleware[];
+    "~addRoute"(_route: import("h3").H3Route): void;
+};
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitro-nightly",
-  "version": "3.1.0-20251026-232057-ce388de2",
+  "version": "3.1.0-20251027-223403-81bd673d",
   "description": "Build and Deploy Universal JavaScript Servers",
   "homepage": "https://nitro.build",
   "repository": "nitrojs/nitro",
@@ -58,7 +58,7 @@
     "db0": "^0.3.4",
     "esbuild": "^0.25.11",
     "fetchdts": "^0.1.7",
-    "h3": "^2.0.1-rc.4",
+    "h3": "^2.0.1-rc.5",
     "jiti": "^2.6.1",
     "nf3": "^0.1.2",
     "ofetch": "^1.4.1",