nitro 2.2.27 → 3.0.0-alpha.0

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

@@ -0,0 +1,33 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+import { awsRequest, awsResponseHeaders } from "./_utils.mjs";
+const nitroApp = useNitroApp();
+export const handler = awslambda.streamifyResponse(
+  async (event, responseStream, context) => {
+    const request = awsRequest(event, context);
+    const response = await nitroApp.fetch(request);
+    response.headers.set("transfer-encoding", "chunked");
+    const httpResponseMetadata = {
+      statusCode: response.status,
+      ...awsResponseHeaders(response)
+    };
+    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
+      );
+      const reader = response.body.getReader();
+      await streamToNodeStream(reader, responseStream);
+      writer.end();
+    }
+  }
+);
+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

@@ -0,0 +1,13 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+import { awsRequest, awsResponseHeaders, awsResponseBody } from "./_utils.mjs";
+const nitroApp = useNitroApp();
+export async function handler(event, context) {
+  const request = awsRequest(event, context);
+  const response = await nitroApp.fetch(request);
+  return {
+    statusCode: response.status,
+    ...awsResponseHeaders(response),
+    ...await awsResponseBody(response)
+  };
+}

package/dist/presets/azure/runtime/_utils.d.mts

@@ -0,0 +1,2 @@
+import type { Cookie } from "@azure/functions";
+export declare function getAzureParsedCookiesFromHeaders(headers: Headers): Cookie[];

package/dist/presets/azure/runtime/_utils.mjs

@@ -0,0 +1,50 @@
+import { parse } from "cookie-es";
+export function getAzureParsedCookiesFromHeaders(headers) {
+  const setCookieHeader = headers.getSetCookie();
+  if (setCookieHeader.length === 0) {
+    return [];
+  }
+  const azureCookies = [];
+  for (const setCookieStr of setCookieHeader) {
+    const setCookie = Object.entries(parse(setCookieStr));
+    if (setCookie.length === 0) {
+      continue;
+    }
+    const [[key, value], ..._setCookieOptions] = setCookie;
+    const setCookieOptions = Object.fromEntries(
+      _setCookieOptions.map(([k, v]) => [k.toLowerCase(), v])
+    );
+    const cookieObject = {
+      name: key,
+      value,
+      domain: setCookieOptions.domain,
+      path: setCookieOptions.path,
+      expires: parseNumberOrDate(setCookieOptions.expires),
+      sameSite: setCookieOptions.samesite,
+      maxAge: parseNumber(setCookieOptions["max-age"]),
+      secure: setCookieStr.includes("Secure") ? true : void 0,
+      httpOnly: setCookieStr.includes("HttpOnly") ? true : void 0
+    };
+    azureCookies.push(cookieObject);
+  }
+  return azureCookies;
+}
+function parseNumberOrDate(expires) {
+  const expiresAsNumber = parseNumber(expires);
+  if (expiresAsNumber !== void 0) {
+    return expiresAsNumber;
+  }
+  const expiresAsDate = new Date(expires);
+  if (!Number.isNaN(expiresAsDate.getTime())) {
+    return expiresAsDate;
+  }
+}
+function parseNumber(maxAge) {
+  if (!maxAge) {
+    return void 0;
+  }
+  const maxAgeAsNumber = Number(maxAge);
+  if (!Number.isNaN(maxAgeAsNumber)) {
+    return maxAgeAsNumber;
+  }
+}

package/dist/presets/azure/runtime/azure-swa.d.mts

@@ -0,0 +1,5 @@
+import "#nitro-internal-pollyfills";
+import type { HttpRequest, HttpResponse } from "@azure/functions";
+export declare function handle(context: {
+    res: HttpResponse;
+}, req: HttpRequest): Promise<void>;

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

@@ -0,0 +1,28 @@
+import "#nitro-internal-pollyfills";
+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;
+  if (req.headers["x-ms-original-url"]) {
+    const parsedURL = parseURL(req.headers["x-ms-original-url"]);
+    url = parsedURL.pathname + parsedURL.search;
+  } else {
+    url = "/api/" + (req.params.url || "");
+  }
+  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.bufferBody ?? req.rawBody
+  });
+  context.res = {
+    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.d.mts

@@ -0,0 +1 @@
+import "#nitro-internal-pollyfills";

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

@@ -0,0 +1,27 @@
+import "#nitro-internal-pollyfills";
+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 ? (
+  // @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(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);
+    }
+    return nitroApp.fetch(req);
+  }
+});
+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

@@ -0,0 +1,20 @@
+import "#nitro-internal-pollyfills";
+import wsAdapter from "crossws/adapters/cloudflare";
+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 ? (
+  // @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);
+    }
+  }
+});

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

@@ -0,0 +1,20 @@
+import "#nitro-internal-pollyfills";
+import type { Request as CFRequest, EventContext, ExecutionContext } from "@cloudflare/workers-types";
+/**
+ * Reference: https://developers.cloudflare.com/workers/runtime-apis/fetch-event/#parameters
+ */
+interface CFPagesEnv {
+    ASSETS: {
+        fetch: (request: CFRequest) => Promise<Response>;
+    };
+    CF_PAGES: "1";
+    CF_PAGES_BRANCH: string;
+    CF_PAGES_COMMIT_SHA: string;
+    CF_PAGES_URL: string;
+    [key: string]: any;
+}
+declare const _default: {
+    fetch(cfReq: CFRequest, env: CFPagesEnv, context: EventContext<CFPagesEnv, string, any>): Promise<any>;
+    scheduled(event: any, env: CFPagesEnv, context: ExecutionContext): void;
+};
+export default _default;

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

@@ -0,0 +1,47 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+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 ? (
+  // @ts-expect-error
+  wsAdapter(nitroApp.h3App.websocket)
+) : void 0;
+export default {
+  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(cfReq.url);
+    if (env.ASSETS && isPublicAssetURL(url.pathname)) {
+      return env.ASSETS.fetch(cfReq);
+    }
+    globalThis.__env__ = env;
+    return nitroApp.fetch(req);
+  },
+  scheduled(event, env, context) {
+    if (import.meta._tasks) {
+      globalThis.__env__ = env;
+      context.waitUntil(
+        runCronTasks(event.cron, {
+          context: {
+            cloudflare: {
+              env,
+              context
+            }
+          },
+          payload: {}
+        })
+      );
+    }
+  }
+};

package/dist/presets/cloudflare/runtime/plugin.dev.d.mts

@@ -0,0 +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.d.mts

@@ -0,0 +1 @@
+import "#nitro-internal-pollyfills";

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

@@ -0,0 +1,17 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+import wsAdapter from "crossws/adapters/deno";
+const nitroApp = useNitroApp();
+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 nitroApp.fetch(req);
+});

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

@@ -0,0 +1,59 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+import { useRuntimeConfig } from "nitro/runtime";
+import { startScheduleRunner } from "nitro/runtime/internal";
+import wsAdapter from "crossws/adapters/deno";
+import destr from "destr";
+const nitroApp = useNitroApp();
+if (Deno.env.get("DEBUG")) {
+  addEventListener(
+    "unhandledrejection",
+    (event) => console.error("[unhandledRejection]", event.reason)
+  );
+  addEventListener(
+    "error",
+    (event) => console.error("[uncaughtException]", event.error)
+  );
+} else {
+  addEventListener(
+    "unhandledrejection",
+    (err) => console.error("[unhandledRejection] " + err)
+  );
+  addEventListener(
+    "error",
+    (event) => console.error("[uncaughtException] " + event.error)
+  );
+}
+const serveOptions = {
+  key: Deno.env.get("NITRO_SSL_KEY"),
+  cert: Deno.env.get("NITRO_SSL_CERT"),
+  port: destr(Deno.env.get("NITRO_PORT") || Deno.env.get("PORT")) || 3e3,
+  hostname: Deno.env.get("NITRO_HOST") || Deno.env.get("HOST"),
+  onListen: (opts) => {
+    const baseURL = (useRuntimeConfig().app.baseURL || "").replace(/\/$/, "");
+    const url = `${opts.hostname}:${opts.port}${baseURL}`;
+    console.log(`Listening ${url}`);
+  }
+};
+if (!serveOptions.key || !serveOptions.cert) {
+  delete serveOptions.key;
+  delete serveOptions.cert;
+}
+Deno.serve(serveOptions, handler);
+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);
+  }
+  return nitroApp.fetch(req);
+}
+if (import.meta._tasks) {
+  startScheduleRunner();
+}
+export default {};

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>;