nitro-nightly 3.0.0-beta-28969273.f7aa9de6 → 4.0.0-20251010-091516-7cafddba

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

@@ -1,40 +1,32 @@
 import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
-import { requestHasBody, runCronTasks } from "nitro/runtime/internal";
+import { runCronTasks } from "nitro/runtime/internal";
 import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
 import wsAdapter from "crossws/adapters/cloudflare";
 const nitroApp = useNitroApp();
-const ws = import.meta._websocket ? wsAdapter(nitroApp.h3App.websocket) : void 0;
+const ws = import.meta._websocket ? (
+  // @ts-expect-error
+  wsAdapter(nitroApp.h3App.websocket)
+) : void 0;
 export default {
-  async fetch(request, env, context) {
-    if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
-      return ws.handleUpgrade(request, env, context);
+  async fetch(cfReq, env, context) {
+    const req = cfReq;
+    req.runtime ??= { name: "cloudflare" };
+    req.runtime.cloudflare ??= { context, env };
+    req.waitUntil = context.waitUntil.bind(context);
+    if (import.meta._websocket && cfReq.headers.get("upgrade") === "websocket") {
+      return ws.handleUpgrade(
+        cfReq,
+        env,
+        context
+      );
     }
-    const url = new URL(request.url);
+    const url = new URL(cfReq.url);
     if (env.ASSETS && isPublicAssetURL(url.pathname)) {
-      return env.ASSETS.fetch(request);
-    }
-    let body;
-    if (requestHasBody(request)) {
-      body = Buffer.from(await request.arrayBuffer());
+      return env.ASSETS.fetch(cfReq);
     }
     globalThis.__env__ = env;
-    return nitroApp.localFetch(url.pathname + url.search, {
-      context: {
-        cf: request.cf,
-        waitUntil: (promise) => context.waitUntil(promise),
-        cloudflare: {
-          request,
-          env,
-          context
-        }
-      },
-      host: url.hostname,
-      protocol: url.protocol,
-      method: request.method,
-      headers: request.headers,
-      body
-    });
+    return nitroApp.fetch(req);
   },
   scheduled(event, env, context) {
     if (import.meta._tasks) {

package/dist/{runtime/internal/timing.d.ts → presets/cloudflare/runtime/plugin.dev.d.mts}

@@ -1,2 +1,3 @@
+import type { NitroAppPlugin } from "nitro/types";
 declare const _default: NitroAppPlugin;
 export default _default;

package/dist/presets/cloudflare/runtime/plugin.dev.mjs

@@ -0,0 +1,89 @@
+const _proxy = _getPlatformProxy().catch((error) => {
+  console.error("Failed to initialize wrangler bindings proxy", error);
+  return _createStubProxy();
+}).then((proxy) => {
+  globalThis.__env__ = proxy.env;
+  return proxy;
+});
+globalThis.__env__ = _proxy.then((proxy) => proxy.env);
+export default (function(nitroApp) {
+  nitroApp.hooks.hook("request", async (event) => {
+    event.req.context ??= {};
+    const proxy = await _proxy;
+    event.req.context.cf = proxy.cf;
+    event.req.context.waitUntil = proxy.ctx.waitUntil.bind(proxy.ctx);
+    const request = new Request(event.req.url);
+    request.cf = proxy.cf;
+    event.req.context.cloudflare = {
+      ...event.req.context.cloudflare,
+      request,
+      env: proxy.env,
+      context: proxy.ctx
+    };
+  });
+  nitroApp.hooks._hooks.request.unshift(nitroApp.hooks._hooks.request.pop());
+  nitroApp.hooks.hook("close", () => {
+    return _proxy?.then((proxy) => proxy.dispose);
+  });
+});
+async function _getPlatformProxy() {
+  const { useRuntimeConfig } = await import("nitro/runtime");
+  const pkg = "wrangler";
+  const { getPlatformProxy } = await import(
+    /* @vite-ignore */
+    pkg
+  ).catch(
+    () => {
+      throw new Error(
+        "Package `wrangler` not found, please install it with: `npx nypm@latest add -D wrangler`"
+      );
+    }
+  );
+  const runtimeConfig = useRuntimeConfig();
+  const proxyOptions = {
+    configPath: runtimeConfig.wrangler.configPath,
+    persist: { path: runtimeConfig.wrangler.persistDir }
+  };
+  if (runtimeConfig.wrangler.environment) {
+    proxyOptions.environment = runtimeConfig.wrangler.environment;
+  }
+  const proxy = await getPlatformProxy(proxyOptions);
+  return proxy;
+}
+function _createStubProxy() {
+  return {
+    env: {},
+    cf: {},
+    ctx: {
+      waitUntil() {
+      },
+      passThroughOnException() {
+      },
+      props: {}
+    },
+    caches: {
+      open() {
+        const result = Promise.resolve(new _CacheStub());
+        return result;
+      },
+      get default() {
+        return new _CacheStub();
+      }
+    },
+    dispose: () => Promise.resolve()
+  };
+}
+class _CacheStub {
+  delete() {
+    const result = Promise.resolve(false);
+    return result;
+  }
+  match() {
+    const result = Promise.resolve(void 0);
+    return result;
+  }
+  put() {
+    const result = Promise.resolve();
+    return result;
+  }
+}

package/dist/presets/deno/runtime/deno-deploy.mjs

@@ -2,30 +2,16 @@ import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
 import wsAdapter from "crossws/adapters/deno";
 const nitroApp = useNitroApp();
-const ws = import.meta._websocket ? wsAdapter(nitroApp.h3App.websocket) : void 0;
-Deno.serve((request, info) => {
-  if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
-    return ws.handleUpgrade(request, info);
+const ws = import.meta._websocket ? (
+  // @ts-expect-error
+  wsAdapter(nitroApp.h3App.websocket)
+) : void 0;
+Deno.serve((denoReq, info) => {
+  const req = denoReq;
+  req.runtime ??= { name: "deno" };
+  req.runtime.deno ??= { info };
+  if (import.meta._websocket && req.headers.get("upgrade") === "websocket") {
+    return ws.handleUpgrade(req, info);
   }
-  return handleRequest(request, info);
+  return nitroApp.fetch(req);
 });
-async function handleRequest(request, info) {
-  const url = new URL(request.url);
-  const headers = new Headers(request.headers);
-  headers.append("x-forwarded-for", info.remoteAddr.hostname);
-  if (!headers.has("x-forwarded-proto")) {
-    headers.set("x-forwarded-proto", "https");
-  }
-  let body;
-  if (request.body) {
-    body = await request.arrayBuffer();
-  }
-  return nitroApp.localFetch(url.pathname + url.search, {
-    host: url.hostname,
-    protocol: url.protocol,
-    headers,
-    method: request.method,
-    redirect: request.redirect,
-    body
-  });
-}

package/dist/presets/deno/runtime/deno-server.d.mts

@@ -0,0 +1,6 @@
+import "#nitro-internal-pollyfills";
+declare global {
+    const Deno: typeof import("@deno/types").Deno;
+}
+declare const _default: {};
+export default _default;

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

@@ -8,20 +8,20 @@ const nitroApp = useNitroApp();
 if (Deno.env.get("DEBUG")) {
   addEventListener(
     "unhandledrejection",
-    (event) => console.error("[nitro] [dev] [unhandledRejection]", event.reason)
+    (event) => console.error("[unhandledRejection]", event.reason)
   );
   addEventListener(
     "error",
-    (event) => console.error("[nitro] [dev] [uncaughtException]", event.error)
+    (event) => console.error("[uncaughtException]", event.error)
   );
 } else {
   addEventListener(
     "unhandledrejection",
-    (err) => console.error("[nitro] [production] [unhandledRejection] " + err)
+    (err) => console.error("[unhandledRejection] " + err)
   );
   addEventListener(
     "error",
-    (event) => console.error("[nitro] [production] [uncaughtException] " + event.error)
+    (event) => console.error("[uncaughtException] " + event.error)
   );
 }
 const serveOptions = {
@@ -40,24 +40,18 @@ if (!serveOptions.key || !serveOptions.cert) {
   delete serveOptions.cert;
 }
 Deno.serve(serveOptions, handler);
-const ws = import.meta._websocket ? wsAdapter(nitroApp.h3App.websocket) : void 0;
-async function handler(request, info) {
-  if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
-    return ws.handleUpgrade(request, info);
+const ws = import.meta._websocket ? (
+  // @ts-expect-error
+  wsAdapter(nitroApp.h3App.websocket)
+) : void 0;
+async function handler(denoReq, info) {
+  const req = denoReq;
+  req.runtime ??= { name: "deno" };
+  req.runtime.deno ??= { info };
+  if (import.meta._websocket && req.headers.get("upgrade") === "websocket") {
+    return ws.handleUpgrade(req, info);
   }
-  const url = new URL(request.url);
-  let body;
-  if (request.body) {
-    body = await request.arrayBuffer();
-  }
-  return nitroApp.localFetch(url.pathname + url.search, {
-    host: url.hostname,
-    protocol: url.protocol,
-    headers: request.headers,
-    method: request.method,
-    redirect: request.redirect,
-    body
-  });
+  return nitroApp.fetch(req);
 }
 if (import.meta._tasks) {
   startScheduleRunner();

package/dist/presets/netlify/runtime/netlify-edge.d.mts

@@ -0,0 +1,3 @@
+import "#nitro-internal-pollyfills";
+import type { Context } from "@netlify/edge-functions";
+export default function netlifyEdge(netlifyReq: Request, context: Context): Promise<any>;

package/dist/presets/netlify/runtime/netlify-edge.mjs

@@ -2,24 +2,16 @@ import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
 import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
 const nitroApp = useNitroApp();
-export default async function netlifyEdge(request, _context) {
-  const url = new URL(request.url);
+export default async function netlifyEdge(netlifyReq, context) {
+  const req = netlifyReq;
+  req.runtime ??= { name: "netlify-edge" };
+  req.runtime.netlify ??= { context };
+  const url = new URL(req.url);
   if (isPublicAssetURL(url.pathname)) {
     return;
   }
-  if (!request.headers.has("x-forwarded-proto") && url.protocol === "https:") {
-    request.headers.set("x-forwarded-proto", "https");
+  if (!req.headers.has("x-forwarded-proto") && url.protocol === "https:") {
+    req.headers.set("x-forwarded-proto", "https");
   }
-  let body;
-  if (request.body) {
-    body = await request.arrayBuffer();
-  }
-  return nitroApp.localFetch(url.pathname + url.search, {
-    host: url.hostname,
-    protocol: url.protocol,
-    headers: request.headers,
-    method: request.method,
-    redirect: request.redirect,
-    body
-  });
+  return nitroApp.fetch(req);
 }

package/dist/presets/netlify/runtime/netlify.mjs

@@ -1,53 +1,24 @@
 import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
-import {
-  getRouteRulesForPath,
-  joinHeaders,
-  normalizeCookieHeader
-} from "nitro/runtime/internal";
 const nitroApp = useNitroApp();
-const handler = async (req) => {
-  const url = new URL(req.url);
-  const relativeUrl = `${url.pathname}${url.search}`;
-  const r = await nitroApp.localCall({
-    url: relativeUrl,
-    headers: req.headers,
-    method: req.method,
-    body: req.body
-  });
-  const headers = normalizeResponseHeaders({
-    ...getCacheHeaders(url.pathname),
-    ...r.headers
-  });
-  return new Response(r.body, {
-    status: r.status,
-    headers
-  });
-};
-export default handler;
 const ONE_YEAR_IN_SECONDS = 365 * 24 * 60 * 60;
-function normalizeResponseHeaders(headers) {
-  const outgoingHeaders = new Headers();
-  for (const [name, header] of Object.entries(headers)) {
-    if (name === "set-cookie") {
-      for (const cookie of normalizeCookieHeader(header)) {
-        outgoingHeaders.append("set-cookie", cookie);
-      }
-    } else if (header !== void 0) {
-      outgoingHeaders.set(name, joinHeaders(header));
-    }
-  }
-  return outgoingHeaders;
-}
-function getCacheHeaders(url) {
-  const { isr } = getRouteRulesForPath(url);
+const handler = async (req) => {
+  const response = await nitroApp.fetch(req);
+  const isr = (req.context?.routeRules || {})?.isr?.options;
   if (isr) {
     const maxAge = typeof isr === "number" ? isr : ONE_YEAR_IN_SECONDS;
     const revalidateDirective = typeof isr === "number" ? `stale-while-revalidate=${ONE_YEAR_IN_SECONDS}` : "must-revalidate";
-    return {
-      "Cache-Control": "public, max-age=0, must-revalidate",
-      "Netlify-CDN-Cache-Control": `public, max-age=${maxAge}, ${revalidateDirective}, durable`
-    };
+    if (!response.headers.has("Cache-Control")) {
+      response.headers.set(
+        "Cache-Control",
+        "public, max-age=0, must-revalidate"
+      );
+    }
+    response.headers.set(
+      "Netlify-CDN-Cache-Control",
+      `public, max-age=${maxAge}, ${revalidateDirective}, durable`
+    );
   }
-  return {};
-}
+  return response;
+};
+export default handler;

package/dist/presets/node/runtime/{cluster.mjs → node-cluster.mjs}

@@ -24,9 +24,7 @@ function runMaster() {
       isShuttingDown = true;
       await new Promise((resolve) => {
         const timeout = setTimeout(() => {
-          console.warn(
-            "[nitro] [cluster] Timeout reached for graceful shutdown. Forcing exit."
-          );
+          console.warn("Timeout reached for graceful shutdown. Forcing exit.");
           resolve();
         }, shutdownConfig.timeout);
         cluster.on("exit", () => {

package/dist/presets/node/runtime/node-middleware.d.mts

@@ -0,0 +1,4 @@
+import "#nitro-internal-pollyfills";
+export declare const middleware: any;
+/** @experimental */
+export declare const websocket: undefined;

package/dist/presets/node/runtime/{node-listener.mjs → node-middleware.mjs}

@@ -1,14 +1,13 @@
 import "#nitro-internal-pollyfills";
-import { toNodeListener } from "h3";
+import { toNodeHandler } from "srvx/node";
 import { useNitroApp } from "nitro/runtime";
 import {
   startScheduleRunner,
   trapUnhandledNodeErrors
 } from "nitro/runtime/internal";
 const nitroApp = useNitroApp();
-export const listener = toNodeListener(nitroApp.h3App);
-export const websocket = import.meta._websocket ? nitroApp.h3App.websocket : void 0;
-export const handler = listener;
+export const middleware = toNodeHandler(nitroApp.fetch);
+export const websocket = import.meta._websocket ? void 0 : void 0;
 trapUnhandledNodeErrors();
 if (import.meta._tasks) {
   startScheduleRunner();

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

@@ -3,9 +3,8 @@ import { Server as HttpServer } from "node:http";
 import { Server as HttpsServer } from "node:https";
 import wsAdapter from "crossws/adapters/node";
 import destr from "destr";
-import { toNodeListener } from "h3";
-import { useNitroApp } from "nitro/runtime";
-import { useRuntimeConfig } from "nitro/runtime";
+import { toNodeHandler } from "srvx/node";
+import { useNitroApp, useRuntimeConfig } from "nitro/runtime";
 import {
   setupGracefulShutdown,
   startScheduleRunner,
@@ -14,7 +13,7 @@ import {
 const cert = process.env.NITRO_SSL_CERT;
 const key = process.env.NITRO_SSL_KEY;
 const nitroApp = useNitroApp();
-const server = cert && key ? new HttpsServer({ key, cert }, toNodeListener(nitroApp.h3App)) : new HttpServer(toNodeListener(nitroApp.h3App));
+const server = cert && key ? new HttpsServer({ key, cert }, toNodeHandler(nitroApp.fetch)) : new HttpServer(toNodeHandler(nitroApp.fetch));
 const port = destr(process.env.NITRO_PORT || process.env.PORT) || 3e3;
 const host = process.env.NITRO_HOST || process.env.HOST;
 const path = process.env.NITRO_UNIX_SOCKET;

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

@@ -0,0 +1,5 @@
+import "#nitro-internal-pollyfills";
+declare const _default: {
+    fetch: any;
+};
+export default _default;

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

@@ -0,0 +1,6 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+const nitroApp = useNitroApp();
+export default {
+  fetch: nitroApp.fetch
+};

package/dist/presets/stormkit/runtime/stormkit.mjs

@@ -1,25 +1,21 @@
 import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
-import { normalizeLambdaOutgoingBody } from "nitro/runtime/internal";
+import { awsResponseBody } from "../../aws-lambda/runtime/_utils.mjs";
 const nitroApp = useNitroApp();
 export const handler = async function(event, context) {
-  const response = await nitroApp.localCall({
-    event,
-    url: event.url,
-    context,
-    headers: event.headers,
+  const req = new Request(event.url, {
     method: event.method || "GET",
-    query: event.query,
+    headers: event.headers,
     body: event.body
   });
-  const awsBody = await normalizeLambdaOutgoingBody(
-    response.body,
-    response.headers
-  );
+  req.runtime ??= { name: "stormkit" };
+  req.runtime.stormkit ??= { event, context };
+  const response = await nitroApp.fetch(req);
+  const { body, isBase64Encoded } = await awsResponseBody(response);
   return {
     statusCode: response.status,
     headers: normalizeOutgoingHeaders(response.headers),
-    [awsBody.type === "text" ? "body" : "buffer"]: awsBody.body
+    [isBase64Encoded ? "buffer" : "body"]: body
   };
 };
 function normalizeOutgoingHeaders(headers) {

package/dist/presets/vercel/runtime/vercel.d.mts

@@ -0,0 +1,8 @@
+import "#nitro-internal-pollyfills";
+import type { ServerRequest } from "srvx";
+declare const _default: {
+    fetch(req: ServerRequest, context: {
+        waitUntil: (promise: Promise<any>) => void;
+    }): any;
+};
+export default _default;

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

@@ -1,17 +1,17 @@
 import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
-import { toNodeListener } from "h3";
-import { parseQuery } from "ufo";
 const nitroApp = useNitroApp();
-const handler = toNodeListener(nitroApp.h3App);
-const listener = function(req, res) {
-  const query = req.headers["x-now-route-matches"];
-  if (query) {
-    const { url } = parseQuery(query);
-    if (url) {
-      req.url = url;
+export default {
+  fetch(req, context) {
+    const isrRoute = req.headers.get("x-now-route-matches");
+    if (isrRoute) {
+      const url = new URL(req.url);
+      url.pathname = decodeURIComponent(isrRoute);
+      req = new Request(url.toString(), req);
     }
+    req.runtime ??= { name: "vercel" };
+    req.runtime.vercel = { context };
+    req.waitUntil = context?.waitUntil;
+    return nitroApp.fetch(req);
   }
-  return handler(req, res);
 };
-export default listener;

package/dist/presets/winterjs/runtime/winterjs.mjs

@@ -1,7 +1,5 @@
 import "#nitro-internal-pollyfills";
-import { toPlainHandler } from "h3";
 import { useNitroApp } from "nitro/runtime";
-import { toBuffer } from "nitro/runtime/internal";
 import { hasProtocol, joinURL } from "ufo";
 const nitroApp = useNitroApp();
 const _handler = toPlainHandler(nitroApp.h3App);
@@ -14,8 +12,10 @@ async function _handleEvent(event) {
       headers: event.request.headers,
       context: {
         waitUntil: (promise) => event.waitUntil(promise),
-        winterjs: {
-          event
+        _platform: {
+          winterjs: {
+            event
+          }
         }
       }
     });
@@ -34,6 +34,24 @@ async function _handleEvent(event) {
 addEventListener("fetch", async (event) => {
   event.respondWith(await _handleEvent(event));
 });
+function toBuffer(data) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    data.pipeTo(
+      new WritableStream({
+        write(chunk) {
+          chunks.push(chunk);
+        },
+        close() {
+          resolve(Buffer.concat(chunks));
+        },
+        abort(reason) {
+          reject(reason);
+        }
+      })
+    ).catch(reject);
+  });
+}
 if (!Headers.prototype.entries) {
   Headers.prototype.entries = function() {
     return [...this];

package/dist/presets/{node/runtime/node-server.d.ts → zeabur/runtime/zeabur.d.mts}

@@ -1,3 +1,3 @@
 import "#nitro-internal-pollyfills";
-declare const _default: {};
+declare const _default: any;
 export default _default;

package/dist/presets/zeabur/runtime/zeabur.mjs

@@ -1,8 +1,4 @@
 import "#nitro-internal-pollyfills";
-import { toNodeListener } from "h3";
+import { toNodeHandler } from "srvx/node";
 import { useNitroApp } from "nitro/runtime";
-const handler = toNodeListener(useNitroApp().h3App);
-const listener = function(req, res) {
-  return handler(req, res);
-};
-export default listener;
+export default toNodeHandler(useNitroApp().fetch);