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

package/dist/presets/aws-lambda/runtime/_utils.mjs

@@ -0,0 +1,102 @@
+import { stringifyQuery } from "ufo";
+export function awsRequest(event, context) {
+  const method = awsEventMethod(event);
+  const url = awsEventURL(event);
+  const headers = awsEventHeaders(event);
+  const body = awsEventBody(event);
+  const req = new Request(url, { method, headers, body });
+  req.runtime ??= { name: "aws-lambda" };
+  req.runtime.aws ??= { event, context };
+  return new Request(url, { method, headers, body });
+}
+function awsEventMethod(event) {
+  return event.httpMethod || event.requestContext?.http?.method || "GET";
+}
+function awsEventURL(event) {
+  const hostname = event.headers.host || event.headers.Host || event.requestContext?.domainName || ".";
+  const path = event.path || event.rawPath;
+  const query = awsEventQuery(event);
+  const protocol = (event.headers["X-Forwarded-Proto"] || event.headers["x-forwarded-proto"]) === "http" ? "http" : "https";
+  return new URL(
+    `${path}${query ? `?${query}` : ""}`,
+    `${protocol}://${hostname}`
+  );
+}
+function awsEventQuery(event) {
+  if (typeof event.rawQueryString === "string") {
+    return event.rawQueryString;
+  }
+  const queryObj = {
+    ...event.queryStringParameters,
+    ...event.multiValueQueryStringParameters
+  };
+  return stringifyQuery(queryObj);
+}
+function awsEventHeaders(event) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(event.headers)) {
+    if (value) {
+      headers.set(key, value);
+    }
+  }
+  if ("cookies" in event && event.cookies) {
+    for (const cookie of event.cookies) {
+      headers.append("cookie", cookie);
+    }
+  }
+  return headers;
+}
+function awsEventBody(event) {
+  if (!event.body) {
+    return void 0;
+  }
+  if (event.isBase64Encoded) {
+    return Buffer.from(event.body || "", "base64");
+  }
+  return event.body;
+}
+export function awsResponseHeaders(response) {
+  const headers = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of response.headers) {
+    if (value) {
+      headers[key] = Array.isArray(value) ? value.join(",") : String(value);
+    }
+  }
+  const cookies = response.headers.getSetCookie();
+  return cookies.length > 0 ? {
+    headers,
+    cookies,
+    // ApiGateway v2
+    multiValueHeaders: { "set-cookie": cookies }
+    // ApiGateway v1
+  } : { headers };
+}
+export async function awsResponseBody(response) {
+  if (!response.body) {
+    return { body: "" };
+  }
+  const buffer = await toBuffer(response.body);
+  const contentType = response.headers.get("content-type") || "";
+  return isTextType(contentType) ? { body: buffer.toString("utf8") } : { body: buffer.toString("base64"), isBase64Encoded: true };
+}
+function isTextType(contentType = "") {
+  return /^text\/|\/(javascript|json|xml)|utf-?8/i.test(contentType);
+}
+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);
+  });
+}

package/dist/presets/aws-lambda/runtime/aws-lambda-streaming.d.mts

@@ -0,0 +1,3 @@
+import "#nitro-internal-pollyfills";
+import type { APIGatewayProxyEventV2 } from "aws-lambda";
+export declare const handler: import("aws-lambda").StreamifyHandler<APIGatewayProxyEventV2, void>;

package/dist/presets/aws-lambda/runtime/aws-lambda-streaming.mjs

@@ -1,53 +1,33 @@
 import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
-import {
-  normalizeLambdaIncomingHeaders,
-  normalizeLambdaOutgoingHeaders
-} from "nitro/runtime/internal";
-import { withQuery } from "ufo";
+import { awsRequest, awsResponseHeaders } from "./_utils.mjs";
 const nitroApp = useNitroApp();
 export const handler = awslambda.streamifyResponse(
   async (event, responseStream, context) => {
-    const query = {
-      ...event.queryStringParameters
-    };
-    const url = withQuery(event.rawPath, query);
-    const method = event.requestContext?.http?.method || "get";
-    if ("cookies" in event && event.cookies) {
-      event.headers.cookie = event.cookies.join(";");
-    }
-    const r = await nitroApp.localCall({
-      event,
-      url,
-      context,
-      headers: normalizeLambdaIncomingHeaders(event.headers),
-      method,
-      query,
-      body: event.isBase64Encoded ? Buffer.from(event.body || "", "base64").toString("utf8") : event.body
-    });
+    const request = awsRequest(event, context);
+    const response = await nitroApp.fetch(request);
+    response.headers.set("transfer-encoding", "chunked");
     const httpResponseMetadata = {
-      statusCode: r.status,
-      headers: {
-        ...normalizeLambdaOutgoingHeaders(r.headers, true),
-        "Transfer-Encoding": "chunked"
-      }
+      statusCode: response.status,
+      ...awsResponseHeaders(response)
     };
-    if (r.body) {
-      const reader = r.body;
+    if (response.body) {
       const writer = awslambda.HttpResponseStream.from(
+        // @ts-expect-error TODO: IMPORTANT! It should be a Writable according to the aws-lambda types
         responseStream,
         httpResponseMetadata
       );
-      await streamToNodeStream(reader.getReader(), responseStream);
+      const reader = response.body.getReader();
+      await streamToNodeStream(reader, responseStream);
       writer.end();
     }
   }
 );
-const streamToNodeStream = async (reader, writer) => {
+async function streamToNodeStream(reader, writer) {
   let readResult = await reader.read();
   while (!readResult.done) {
     writer.write(readResult.value);
     readResult = await reader.read();
   }
   writer.end();
-};
+}

package/dist/presets/aws-lambda/runtime/aws-lambda.d.mts

@@ -0,0 +1,3 @@
+import "#nitro-internal-pollyfills";
+import type { APIGatewayProxyEvent, APIGatewayProxyEventV2, APIGatewayProxyResult, APIGatewayProxyResultV2, Context } from "aws-lambda";
+export declare function handler(event: APIGatewayProxyEvent | APIGatewayProxyEventV2, context: Context): Promise<APIGatewayProxyResult | APIGatewayProxyResultV2>;

package/dist/presets/aws-lambda/runtime/aws-lambda.mjs

@@ -1,45 +1,13 @@
 import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
-import {
-  normalizeCookieHeader,
-  normalizeLambdaIncomingHeaders,
-  normalizeLambdaOutgoingBody,
-  normalizeLambdaOutgoingHeaders
-} from "nitro/runtime/internal";
-import { withQuery } from "ufo";
+import { awsRequest, awsResponseHeaders, awsResponseBody } from "./_utils.mjs";
 const nitroApp = useNitroApp();
 export async function handler(event, context) {
-  const query = {
-    ...event.queryStringParameters,
-    ...event.multiValueQueryStringParameters
-  };
-  const url = withQuery(
-    event.path || event.rawPath,
-    query
-  );
-  const method = event.httpMethod || event.requestContext?.http?.method || "get";
-  if ("cookies" in event && event.cookies) {
-    event.headers.cookie = event.cookies.join(";");
-  }
-  const r = await nitroApp.localCall({
-    event,
-    url,
-    context,
-    headers: normalizeLambdaIncomingHeaders(event.headers),
-    method,
-    query,
-    body: event.isBase64Encoded ? Buffer.from(event.body || "", "base64").toString("utf8") : event.body
-  });
-  const isApiGwV2 = "cookies" in event || "rawPath" in event;
-  const awsBody = await normalizeLambdaOutgoingBody(r.body, r.headers);
-  const cookies = normalizeCookieHeader(r.headers["set-cookie"]);
+  const request = awsRequest(event, context);
+  const response = await nitroApp.fetch(request);
   return {
-    ...cookies.length > 0 && {
-      ...isApiGwV2 ? { cookies } : { multiValueHeaders: { "set-cookie": cookies } }
-    },
-    statusCode: r.status,
-    headers: normalizeLambdaOutgoingHeaders(r.headers, true),
-    body: awsBody.body,
-    isBase64Encoded: awsBody.type === "binary"
+    statusCode: response.status,
+    ...awsResponseHeaders(response),
+    ...await awsResponseBody(response)
   };
 }

package/dist/{runtime/internal/utils.azure.d.ts → presets/azure/runtime/_utils.d.mts}

@@ -1,2 +1,2 @@
 import type { Cookie } from "@azure/functions";
-export declare function getAzureParsedCookiesFromHeaders(headers: Record<string, number | string | string[] | undefined>): Cookie[];
+export declare function getAzureParsedCookiesFromHeaders(headers: Headers): Cookie[];

package/dist/{runtime/internal/utils.azure.mjs → presets/azure/runtime/_utils.mjs}

@@ -1,12 +1,11 @@
 import { parse } from "cookie-es";
-import { splitCookiesString } from "h3";
 export function getAzureParsedCookiesFromHeaders(headers) {
-  const setCookieHeader = headers["set-cookie"];
-  if (!setCookieHeader || typeof setCookieHeader === "number" || setCookieHeader.length === 0) {
+  const setCookieHeader = headers.getSetCookie();
+  if (setCookieHeader.length === 0) {
     return [];
   }
   const azureCookies = [];
-  for (const setCookieStr of splitCookiesString(setCookieHeader)) {
+  for (const setCookieStr of setCookieHeader) {
     const setCookie = Object.entries(parse(setCookieStr));
     if (setCookie.length === 0) {
       continue;

package/dist/presets/azure/runtime/azure-swa.mjs

@@ -1,10 +1,7 @@
 import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
-import {
-  getAzureParsedCookiesFromHeaders,
-  normalizeLambdaOutgoingHeaders
-} from "nitro/runtime/internal";
 import { parseURL } from "ufo";
+import { useNitroApp } from "nitro/runtime";
+import { getAzureParsedCookiesFromHeaders } from "./_utils.mjs";
 const nitroApp = useNitroApp();
 export async function handle(context, req) {
   let url;
@@ -14,17 +11,18 @@ export async function handle(context, req) {
   } else {
     url = "/api/" + (req.params.url || "");
   }
-  const { body, status, headers } = await nitroApp.localCall({
-    url,
-    headers: req.headers,
+  const response = await nitroApp.fetch(url, {
     method: req.method || void 0,
+    // https://github.com/Azure/azure-functions-nodejs-worker/issues/294
     // https://github.com/Azure/azure-functions-host/issues/293
-    body: req.rawBody
+    body: req.bufferBody ?? req.rawBody
   });
   context.res = {
-    status,
-    cookies: getAzureParsedCookiesFromHeaders(headers),
-    headers: normalizeLambdaOutgoingHeaders(headers, true),
-    body
+    status: response.status,
+    body: response.body,
+    cookies: getAzureParsedCookiesFromHeaders(response.headers),
+    headers: Object.fromEntries(
+      [...response.headers.entries()].filter(([key]) => key !== "set-cookie")
+    )
   };
 }

package/dist/presets/bun/runtime/bun.mjs

@@ -3,30 +3,25 @@ import { useNitroApp } from "nitro/runtime";
 import { startScheduleRunner } from "nitro/runtime/internal";
 import wsAdapter from "crossws/adapters/bun";
 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;
 const server = Bun.serve({
   port: process.env.NITRO_PORT || process.env.PORT || 3e3,
+  hostname: process.env.NITRO_HOST || process.env.HOST,
   websocket: import.meta._websocket ? ws.websocket : void 0,
-  async fetch(req, server2) {
-    if (import.meta._websocket && await ws.handleUpgrade(req, server2)) {
-      return;
+  async fetch(bunReq, server2) {
+    const req = bunReq;
+    req.runtime ??= { name: "bun" };
+    req.runtime.bun ??= { server: server2 };
+    if (import.meta._websocket && req.headers.get("upgrade") === "websocket") {
+      return ws.handleUpgrade(req, server2);
     }
-    const url = new URL(req.url);
-    let body;
-    if (req.body) {
-      body = await req.arrayBuffer();
-    }
-    return nitroApp.localFetch(url.pathname + url.search, {
-      host: url.hostname,
-      protocol: url.protocol,
-      headers: req.headers,
-      method: req.method,
-      redirect: req.redirect,
-      body
-    });
+    return nitroApp.fetch(req);
   }
 });
-console.log(`Listening on http://localhost:${server.port}...`);
+console.log(`Listening on ${server.url}...`);
 if (import.meta._tasks) {
   startScheduleRunner();
 }

package/dist/presets/cloudflare/runtime/_module-handler.d.mts

@@ -0,0 +1,13 @@
+import "#nitro-internal-pollyfills";
+import type * as CF from "@cloudflare/workers-types";
+import type { ExportedHandler } from "@cloudflare/workers-types";
+type MaybePromise<T> = T | Promise<T>;
+export declare function createHandler<Env>(hooks: {
+    fetch: (...params: [
+        ...Parameters<NonNullable<ExportedHandler<Env>["fetch"]>>,
+        url: URL,
+        cfContextExtras: any
+    ]) => MaybePromise<Response | CF.Response | undefined>;
+}): ExportedHandler<Env>;
+export declare function fetchHandler(cfReq: Request | CF.Request, env: unknown, context: CF.ExecutionContext | DurableObjectState, url: URL | undefined, nitroApp: any, ctxExt: any): Promise<Response>;
+export {};

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

@@ -0,0 +1,93 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+import { runCronTasks } from "nitro/runtime/internal";
+export function createHandler(hooks) {
+  const nitroApp = useNitroApp();
+  return {
+    async fetch(request, env, context) {
+      const ctxExt = {};
+      const url = new URL(request.url);
+      if (hooks.fetch) {
+        const res = await hooks.fetch(request, env, context, url, ctxExt);
+        if (res) {
+          return res;
+        }
+      }
+      return fetchHandler(request, env, context, url, nitroApp, ctxExt);
+    },
+    scheduled(controller, env, context) {
+      globalThis.__env__ = env;
+      context.waitUntil(
+        nitroApp.hooks.callHook("cloudflare:scheduled", {
+          controller,
+          env,
+          context
+        })
+      );
+      if (import.meta._tasks) {
+        context.waitUntil(
+          runCronTasks(controller.cron, {
+            context: {
+              cloudflare: {
+                env,
+                context
+              }
+            },
+            payload: {}
+          })
+        );
+      }
+    },
+    email(message, env, context) {
+      globalThis.__env__ = env;
+      context.waitUntil(
+        nitroApp.hooks.callHook("cloudflare:email", {
+          message,
+          event: message,
+          // backward compat
+          env,
+          context
+        })
+      );
+    },
+    queue(batch, env, context) {
+      globalThis.__env__ = env;
+      context.waitUntil(
+        nitroApp.hooks.callHook("cloudflare:queue", {
+          batch,
+          event: batch,
+          env,
+          context
+        })
+      );
+    },
+    tail(traces, env, context) {
+      globalThis.__env__ = env;
+      context.waitUntil(
+        nitroApp.hooks.callHook("cloudflare:tail", {
+          traces,
+          env,
+          context
+        })
+      );
+    },
+    trace(traces, env, context) {
+      globalThis.__env__ = env;
+      context.waitUntil(
+        nitroApp.hooks.callHook("cloudflare:trace", {
+          traces,
+          env,
+          context
+        })
+      );
+    }
+  };
+}
+export async function fetchHandler(cfReq, env, context, url = new URL(cfReq.url), nitroApp = useNitroApp(), ctxExt) {
+  globalThis.__env__ = env;
+  const req = cfReq;
+  req.runtime ??= { name: "cloudflare" };
+  req.runtime.cloudflare ??= { context, env };
+  req.waitUntil = context.waitUntil.bind(context);
+  return nitroApp.fetch(req);
+}

package/dist/presets/cloudflare/runtime/cloudflare-durable.d.mts

@@ -0,0 +1,19 @@
+import "#nitro-internal-pollyfills";
+import type * as CF from "@cloudflare/workers-types";
+import { DurableObject } from "cloudflare:workers";
+declare const DURABLE_BINDING = "$DurableObject";
+interface Env {
+    ASSETS?: {
+        fetch: typeof CF.fetch;
+    };
+    [DURABLE_BINDING]?: CF.DurableObjectNamespace;
+}
+declare const _default: CF.ExportedHandler<Env, unknown, unknown>;
+export default _default;
+export declare class $DurableObject extends DurableObject {
+    constructor(state: DurableObjectState, env: Record<string, any>);
+    fetch(request: Request): Promise<Response>;
+    alarm(): void | Promise<void>;
+    webSocketMessage(client: WebSocket, message: ArrayBuffer | string): Promise<void>;
+    webSocketClose(client: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void>;
+}

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

@@ -0,0 +1,74 @@
+import "#nitro-internal-pollyfills";
+import { DurableObject } from "cloudflare:workers";
+import wsAdapter from "crossws/adapters/cloudflare";
+import { useNitroApp } 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 getDurableStub = (env) => {
+  const binding = env[DURABLE_BINDING];
+  if (!binding) {
+    throw new Error(
+      `Durable Object binding "${DURABLE_BINDING}" not available.`
+    );
+  }
+  const id = binding.idFromName(DURABLE_INSTANCE);
+  return binding.get(id);
+};
+const ws = import.meta._websocket ? wsAdapter({
+  // TODO!
+  // ...nitroApp.h3App.websocket,
+  instanceName: DURABLE_INSTANCE,
+  bindingName: DURABLE_BINDING
+}) : void 0;
+export default createHandler({
+  fetch(request, env, context, url, ctxExt) {
+    if (env.ASSETS && isPublicAssetURL(url.pathname)) {
+      return env.ASSETS.fetch(request);
+    }
+    ctxExt.durableFetch = (req = request) => getDurableStub(env).fetch(req);
+    if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
+      return ws.handleUpgrade(request, env, context);
+    }
+  }
+});
+export class $DurableObject extends DurableObject {
+  constructor(state, env) {
+    super(state, env);
+    state.waitUntil(
+      nitroApp.hooks.callHook("cloudflare:durable:init", this, {
+        state,
+        env
+      })
+    );
+    if (import.meta._websocket) {
+      ws.handleDurableInit(this, state, env);
+    }
+  }
+  fetch(request) {
+    if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
+      return ws.handleDurableUpgrade(this, request);
+    }
+    const url = new URL(request.url);
+    return fetchHandler(request, this.env, this.ctx, url, nitroApp, {
+      durable: this
+    });
+  }
+  alarm() {
+    this.ctx.waitUntil(
+      nitroApp.hooks.callHook("cloudflare:durable:alarm", this)
+    );
+  }
+  async webSocketMessage(client, message) {
+    if (import.meta._websocket) {
+      return ws.handleDurableMessage(this, client, message);
+    }
+  }
+  async webSocketClose(client, code, reason, wasClean) {
+    if (import.meta._websocket) {
+      return ws.handleDurableClose(this, client, code, reason, wasClean);
+    }
+  }
+}

package/dist/presets/cloudflare/runtime/cloudflare-module.d.mts

@@ -0,0 +1,9 @@
+import "#nitro-internal-pollyfills";
+import type { fetch } from "@cloudflare/workers-types";
+interface Env {
+    ASSETS?: {
+        fetch: typeof fetch;
+    };
+}
+declare const _default: import("@cloudflare/workers-types").ExportedHandler<Env, unknown, unknown>;
+export default _default;

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

@@ -1,104 +1,20 @@
 import "#nitro-internal-pollyfills";
-import { useNitroApp } from "nitro/runtime";
-import { useRuntimeConfig } from "nitro/runtime";
-import { runCronTasks } from "nitro/runtime/internal";
-import { requestHasBody } from "nitro/runtime/internal";
-import { getPublicAssetMeta } from "#nitro-internal-virtual/public-assets";
-import {
-  getAssetFromKV,
-  mapRequestToAsset
-} from "@cloudflare/kv-asset-handler";
 import wsAdapter from "crossws/adapters/cloudflare";
-import { withoutBase } from "ufo";
-import manifest from "__STATIC_CONTENT_MANIFEST";
+import { useNitroApp } from "nitro/runtime";
+import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
+import { createHandler } from "./_module-handler.mjs";
 const nitroApp = useNitroApp();
-const ws = import.meta._websocket ? wsAdapter(nitroApp.h3App.websocket) : void 0;
-export default {
-  async fetch(request, env, context) {
+const ws = import.meta._websocket ? (
+  // @ts-expect-error
+  wsAdapter(nitroApp.h3App.websocket)
+) : void 0;
+export default createHandler({
+  fetch(request, env, context, url) {
+    if (env.ASSETS && isPublicAssetURL(url.pathname)) {
+      return env.ASSETS.fetch(request);
+    }
     if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
       return ws.handleUpgrade(request, env, context);
     }
-    try {
-      return await getAssetFromKV(
-        {
-          request,
-          waitUntil(promise) {
-            return context.waitUntil(promise);
-          }
-        },
-        {
-          cacheControl: assetsCacheControl,
-          mapRequestToAsset: baseURLModifier,
-          ASSET_NAMESPACE: env.__STATIC_CONTENT,
-          ASSET_MANIFEST: JSON.parse(manifest)
-        }
-      );
-    } catch {
-    }
-    const url = new URL(request.url);
-    let body;
-    if (requestHasBody(request)) {
-      body = Buffer.from(await request.arrayBuffer());
-    }
-    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
-    });
-  },
-  scheduled(event, env, context) {
-    if (import.meta._tasks) {
-      globalThis.__env__ = env;
-      context.waitUntil(
-        runCronTasks(event.cron, {
-          context: {
-            cloudflare: {
-              env,
-              context
-            }
-          },
-          payload: {}
-        })
-      );
-    }
-  },
-  email(event, env, context) {
-    globalThis.__env__ = env;
-    context.waitUntil(
-      nitroApp.hooks.callHook("cloudflare:email", { event, env, context })
-    );
-  },
-  queue(event, env, context) {
-    globalThis.__env__ = env;
-    context.waitUntil(
-      nitroApp.hooks.callHook("cloudflare:queue", { event, env, context })
-    );
-  }
-};
-function assetsCacheControl(_request) {
-  const url = new URL(_request.url);
-  const meta = getPublicAssetMeta(url.pathname);
-  if (meta.maxAge) {
-    return {
-      browserTTL: meta.maxAge,
-      edgeTTL: meta.maxAge
-    };
   }
-  return {};
-}
-const baseURLModifier = (request) => {
-  const url = withoutBase(request.url, useRuntimeConfig().app.baseURL);
-  return mapRequestToAsset(new Request(url, request));
-};
+});

package/dist/presets/cloudflare/runtime/{cloudflare-pages.d.ts → cloudflare-pages.d.mts}

@@ -14,7 +14,7 @@ interface CFPagesEnv {
     [key: string]: any;
 }
 declare const _default: {
-    fetch(request: CFRequest, env: CFPagesEnv, context: EventContext<CFPagesEnv, string, any>): Promise<any>;
+    fetch(cfReq: CFRequest, env: CFPagesEnv, context: EventContext<CFPagesEnv, string, any>): Promise<any>;
     scheduled(event: any, env: CFPagesEnv, context: ExecutionContext): void;
 };
 export default _default;