@depup/nitro 3.0.260311-beta-depup.0

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 : undefined,
+			httpOnly: setCookieStr.includes("HttpOnly") ? true : undefined
+		};
+		azureCookies.push(cookieObject);
+	}
+	return azureCookies;
+}
+function parseNumberOrDate(expires) {
+	const expiresAsNumber = parseNumber(expires);
+	if (expiresAsNumber !== undefined) {
+		return expiresAsNumber;
+	}
+	// Convert to Date if possible
+	const expiresAsDate = new Date(expires);
+	if (!Number.isNaN(expiresAsDate.getTime())) {
+		return expiresAsDate;
+	}
+}
+function parseNumber(maxAge) {
+	if (!maxAge) {
+		return undefined;
+	}
+	// Convert to number if possible
+	const maxAgeAsNumber = Number(maxAge);
+	if (!Number.isNaN(maxAgeAsNumber)) {
+		return maxAgeAsNumber;
+	}
+}

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

@@ -0,0 +1,30 @@
+import "#nitro/virtual/polyfills";
+import { parseURL } from "ufo";
+import { useNitroApp } from "nitro/app";
+import { getAzureParsedCookiesFromHeaders } from "./_utils.mjs";
+const nitroApp = useNitroApp();
+export async function handle(context, req) {
+	let url;
+	if (req.headers["x-ms-original-url"]) {
+		// This URL has been proxied as there was no static file matching it.
+		const parsedURL = parseURL(req.headers["x-ms-original-url"]);
+		url = parsedURL.pathname + parsedURL.search;
+	} else {
+		// Because Azure SWA handles /api/* calls differently they
+		// never hit the proxy and we have to reconstitute the URL.
+		url = "/api/" + (req.params.url || "");
+	}
+	const request = new Request(url, {
+		method: req.method || undefined,
+		body: req.bufferBody ?? req.rawBody
+	});
+	const response = await nitroApp.fetch(request);
+	// (v3 - current) https://learn.microsoft.com/en-us/azure/azure-functions/functions-reference-node?tabs=typescript%2Cwindows%2Cazure-cli&pivots=nodejs-model-v3#http-response
+	// (v4) https://learn.microsoft.com/en-us/azure/azure-functions/functions-reference-node?tabs=typescript%2Cwindows%2Cazure-cli&pivots=nodejs-model-v4#http-response
+	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.mjs

@@ -0,0 +1,40 @@
+import "#nitro/virtual/polyfills";
+import { serve } from "srvx/bun";
+import wsAdapter from "crossws/adapters/bun";
+import { useNitroApp } from "nitro/app";
+import { startScheduleRunner } from "#nitro/runtime/task";
+import { trapUnhandledErrors } from "#nitro/runtime/error/hooks";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
+const _parsedPort = Number.parseInt(process.env.NITRO_PORT ?? process.env.PORT ?? "");
+const port = Number.isNaN(_parsedPort) ? 3e3 : _parsedPort;
+const host = process.env.NITRO_HOST || process.env.HOST;
+const cert = process.env.NITRO_SSL_CERT;
+const key = process.env.NITRO_SSL_KEY;
+// const socketPath = process.env.NITRO_UNIX_SOCKET; // TODO
+const nitroApp = useNitroApp();
+let _fetch = nitroApp.fetch;
+const ws = import.meta._websocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
+if (import.meta._websocket) {
+	_fetch = (req) => {
+		if (req.headers.get("upgrade") === "websocket") {
+			return ws.handleUpgrade(req, req.runtime.bun.server);
+		}
+		return nitroApp.fetch(req);
+	};
+}
+const server = serve({
+	port,
+	hostname: host,
+	tls: cert && key ? {
+		cert,
+		key
+	} : undefined,
+	fetch: _fetch,
+	bun: { websocket: import.meta._websocket ? ws?.websocket : undefined }
+});
+trapUnhandledErrors();
+// Scheduled tasks
+if (import.meta._tasks) {
+	startScheduleRunner({ waitUntil: server.waitUntil });
+}
+export default {};

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

@@ -0,0 +1,87 @@
+import "#nitro/virtual/polyfills";
+import { runCronTasks } from "#nitro/runtime/task";
+import { useNitroApp, useNitroHooks } from "nitro/app";
+export function createHandler(hooks) {
+	const nitroApp = useNitroApp();
+	const nitroHooks = useNitroHooks();
+	return {
+		async fetch(request, env, context) {
+			globalThis.__env__ = env;
+			augmentReq(request, {
+				env,
+				context
+			});
+			const ctxExt = {};
+			const url = new URL(request.url);
+			// Preset-specific logic
+			if (hooks.fetch) {
+				const res = await hooks.fetch(request, env, context, url, ctxExt);
+				if (res) {
+					return res;
+				}
+			}
+			return await nitroApp.fetch(request);
+		},
+		scheduled(controller, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:scheduled", {
+				controller,
+				env,
+				context
+			}) || Promise.resolve());
+			if (import.meta._tasks) {
+				context.waitUntil(runCronTasks(controller.cron, {
+					context: { cloudflare: {
+						env,
+						context
+					} },
+					payload: {}
+				}));
+			}
+		},
+		email(message, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:email", {
+				message,
+				event: message,
+				env,
+				context
+			}) || Promise.resolve());
+		},
+		queue(batch, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:queue", {
+				batch,
+				event: batch,
+				env,
+				context
+			}) || Promise.resolve());
+		},
+		tail(traces, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:tail", {
+				traces,
+				env,
+				context
+			}) || Promise.resolve());
+		},
+		trace(traces, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:trace", {
+				traces,
+				env,
+				context
+			}) || Promise.resolve());
+		}
+	};
+}
+export function augmentReq(cfReq, ctx) {
+	const req = cfReq;
+	req.ip = cfReq.headers.get("cf-connecting-ip") || undefined;
+	req.runtime ??= { name: "cloudflare" };
+	req.runtime.cloudflare = {
+		...req.runtime.cloudflare,
+		...ctx
+	};
+	req.waitUntil = ctx.context?.waitUntil.bind(ctx.context);
+}

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

@@ -0,0 +1,72 @@
+import "#nitro/virtual/polyfills";
+import { DurableObject } from "cloudflare:workers";
+import wsAdapter from "crossws/adapters/cloudflare";
+import { createHandler, augmentReq } from "./_module-handler.mjs";
+import { useNitroApp, useNitroHooks } from "nitro/app";
+import { isPublicAssetURL } from "#nitro/virtual/public-assets";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
+const DURABLE_BINDING = "$DurableObject";
+const DURABLE_INSTANCE = "server";
+const nitroApp = useNitroApp();
+const nitroHooks = useNitroHooks();
+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({
+	resolve: resolveWebsocketHooks,
+	instanceName: DURABLE_INSTANCE,
+	bindingName: DURABLE_BINDING
+}) : undefined;
+export default createHandler({ fetch(request, env, context, url, ctxExt) {
+	// Static assets fallback (optional binding)
+	if (env.ASSETS && isPublicAssetURL(url.pathname)) {
+		return env.ASSETS.fetch(request);
+	}
+	// Expose stub fetch to the context
+	ctxExt.durableFetch = (req = request) => getDurableStub(env).fetch(req);
+	// Websocket upgrade
+	// https://crossws.unjs.io/adapters/cloudflare#durable-objects
+	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(nitroHooks.callHook("cloudflare:durable:init", this, {
+			state,
+			env
+		}) || Promise.resolve());
+		if (import.meta._websocket) {
+			ws.handleDurableInit(this, state, env);
+		}
+	}
+	fetch(request) {
+		augmentReq(request, {
+			env: this.env,
+			context: this.ctx
+		});
+		if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
+			return ws.handleDurableUpgrade(this, request);
+		}
+		return nitroApp.fetch(request);
+	}
+	alarm() {
+		this.ctx.waitUntil(nitroHooks.callHook("cloudflare:durable:alarm", this) || Promise.resolve());
+	}
+	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.mjs

@@ -0,0 +1,17 @@
+import "#nitro/virtual/polyfills";
+import wsAdapter from "crossws/adapters/cloudflare";
+import { isPublicAssetURL } from "#nitro/virtual/public-assets";
+import { createHandler } from "./_module-handler.mjs";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
+const ws = import.meta._websocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
+export default createHandler({ fetch(cfRequest, env, context, url) {
+	// Static assets fallback (optional binding)
+	if (env.ASSETS && isPublicAssetURL(url.pathname)) {
+		return env.ASSETS.fetch(cfRequest);
+	}
+	// Websocket upgrade
+	// https://crossws.unjs.io/adapters/cloudflare
+	if (import.meta._websocket && cfRequest.headers.get("upgrade") === "websocket") {
+		return ws.handleUpgrade(cfRequest, env, context);
+	}
+} });

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

@@ -0,0 +1,39 @@
+import "#nitro/virtual/polyfills";
+import wsAdapter from "crossws/adapters/cloudflare";
+import { useNitroApp } from "nitro/app";
+import { isPublicAssetURL } from "#nitro/virtual/public-assets";
+import { runCronTasks } from "#nitro/runtime/task";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
+import { augmentReq } from "./_module-handler.mjs";
+const nitroApp = useNitroApp();
+const ws = import.meta._websocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
+export default {
+	async fetch(cfReq, env, context) {
+		augmentReq(cfReq, {
+			env,
+			context
+		});
+		// Websocket upgrade
+		// https://crossws.unjs.io/adapters/cloudflare
+		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);
+		}
+		return nitroApp.fetch(cfReq);
+	},
+	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.mjs

@@ -0,0 +1,96 @@
+import { useRuntimeConfig } from "nitro/runtime-config";
+const proxy = await _getPlatformProxy().catch((error) => {
+	console.error("Failed to initialize wrangler bindings proxy", error);
+	return _createStubProxy();
+});
+globalThis.__env__ = proxy.env;
+globalThis.__wait_until__ = proxy.ctx.waitUntil.bind(proxy.ctx);
+const cloudflareDevPlugin = function(nitroApp) {
+	nitroApp.hooks.hook("request", async (event) => {
+		event.req.context ??= {};
+		// Inject the various cf values from the proxy in event and event.context
+		event.req.context.cf = proxy.cf;
+		event.req.context.waitUntil = proxy.ctx.waitUntil.bind(proxy.ctx);
+		const request = event.req;
+		request.cf = proxy.cf;
+		event.req.context.cloudflare = {
+			...event.req.context.cloudflare,
+			request,
+			env: proxy.env,
+			context: proxy.ctx
+		};
+		// Replicate Nitro production behavior
+		// https://github.com/unjs/nitro/blob/main/src/runtime/entries/cloudflare-pages.ts#L55
+		// https://github.com/unjs/nitro/blob/main/src/runtime/app.ts#L120
+		// TODO: Update for v3
+		// (event.node.req as any).__unenv__ = {
+		//   ...(event.node.req as any).__unenv__,
+		//   waitUntil: event.context.waitUntil,
+		// };
+	});
+	// https://github.com/pi0/nitro-cloudflare-dev/issues/5
+	// https://github.com/unjs/hookable/issues/98
+	// @ts-expect-error
+	nitroApp.hooks._hooks.request.unshift(nitroApp.hooks._hooks.request.pop());
+	// Dispose proxy when Nitro is closed
+	nitroApp.hooks.hook("close", () => {
+		return proxy?.dispose();
+	});
+};
+export default cloudflareDevPlugin;
+async function _getPlatformProxy() {
+	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 }
+	};
+	// TODO: investigate why
+	// https://github.com/pi0/nitro-cloudflare-dev/issues/51
+	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(undefined);
+		return result;
+	}
+	put() {
+		const result = Promise.resolve();
+		return result;
+	}
+}

package/dist/presets/cloudflare/runtime/shims/workers.dev.mjs

@@ -0,0 +1,27 @@
+// Shim for "cloudflare:workers" import in dev environment
+
+// unenv shim respects __env__
+export { env } from "unenv/node/internal/process/env";
+
+export async function waitUntil(promise) {
+  await globalThis.__wait_until__?.(promise);
+}
+
+export function withEnv(newEnv, fn) {
+  throw new Error("cf.withEnv is not implemented in dev env currently.");
+}
+
+class NotImplemented {
+  constructor() {
+    throw new Error("Not implemented in dev env currently.");
+  }
+}
+
+export class DurableObject extends NotImplemented {}
+export class RpcPromise extends NotImplemented {}
+export class RpcProperty extends NotImplemented {}
+export class RpcStub extends NotImplemented {}
+export class RpcTarget extends NotImplemented {}
+export class ServiceStub extends NotImplemented {}
+export class WorkerEntrypoint extends NotImplemented {}
+export class WorkflowEntrypoint extends NotImplemented {}

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

@@ -0,0 +1,19 @@
+import "#nitro/virtual/polyfills";
+import wsAdapter from "crossws/adapters/deno";
+import { useNitroApp } from "nitro/app";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
+const nitroApp = useNitroApp();
+const ws = import.meta._websocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
+// TODO: Migrate to srvx to provide request IP
+Deno.serve((denoReq, info) => {
+	// srvx compatibility
+	const req = denoReq;
+	req.runtime ??= { name: "deno" };
+	req.runtime.deno ??= { info };
+	// TODO: Support remoteAddr
+	// https://crossws.unjs.io/adapters/deno
+	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.mjs

@@ -0,0 +1,39 @@
+import "#nitro/virtual/polyfills";
+import { serve } from "srvx/deno";
+import wsAdapter from "crossws/adapters/deno";
+import { useNitroApp } from "nitro/app";
+import { startScheduleRunner } from "#nitro/runtime/task";
+import { trapUnhandledErrors } from "#nitro/runtime/error/hooks";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
+const _parsedPort = Number.parseInt(process.env.NITRO_PORT ?? process.env.PORT ?? "");
+const port = Number.isNaN(_parsedPort) ? 3e3 : _parsedPort;
+const host = process.env.NITRO_HOST || process.env.HOST;
+const cert = process.env.NITRO_SSL_CERT;
+const key = process.env.NITRO_SSL_KEY;
+// const socketPath = process.env.NITRO_UNIX_SOCKET; // TODO
+const nitroApp = useNitroApp();
+let _fetch = nitroApp.fetch;
+if (import.meta._websocket) {
+	const { handleUpgrade } = wsAdapter({ resolve: resolveWebsocketHooks });
+	_fetch = (req) => {
+		if (req.headers.get("upgrade") === "websocket") {
+			return handleUpgrade(req, req.runtime.deno.info);
+		}
+		return nitroApp.fetch(req);
+	};
+}
+const server = serve({
+	port,
+	hostname: host,
+	tls: cert && key ? {
+		cert,
+		key
+	} : undefined,
+	fetch: _fetch
+});
+trapUnhandledErrors();
+// Scheduled tasks
+if (import.meta._tasks) {
+	startScheduleRunner({ waitUntil: server.waitUntil });
+}
+export default {};

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

@@ -0,0 +1,20 @@
+import "#nitro/virtual/polyfills";
+import { useNitroApp } from "nitro/app";
+import { isPublicAssetURL } from "#nitro/virtual/public-assets";
+const nitroApp = useNitroApp();
+// https://docs.netlify.com/edge-functions/api/
+export default async function netlifyEdge(netlifyReq, context) {
+	// srvx compatibility
+	const req = netlifyReq;
+	req.ip = context.ip;
+	req.runtime ??= { name: "netlify-edge" };
+	req.runtime.netlify ??= { context };
+	const url = new URL(req.url);
+	if (isPublicAssetURL(url.pathname)) {
+		return;
+	}
+	if (!req.headers.has("x-forwarded-proto") && url.protocol === "https:") {
+		req.headers.set("x-forwarded-proto", "https");
+	}
+	return nitroApp.fetch(req);
+}

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

@@ -0,0 +1,20 @@
+import "#nitro/virtual/polyfills";
+import { useNitroApp } from "nitro/app";
+const nitroApp = useNitroApp();
+const ONE_YEAR_IN_SECONDS = 365 * 24 * 60 * 60;
+const handler = async (req) => {
+	req.runtime ??= { name: "netlify" };
+	req.ip ??= req.headers.get("x-nf-client-connection-ip") || undefined;
+	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";
+		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 response;
+};
+export default handler;

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

@@ -0,0 +1,54 @@
+import "#nitro/virtual/polyfills";
+import cluster from "node:cluster";
+import { NodeRequest, serve } from "srvx/node";
+import wsAdapter from "crossws/adapters/node";
+import { useNitroApp } from "nitro/app";
+import { startScheduleRunner } from "#nitro/runtime/task";
+import { trapUnhandledErrors } from "#nitro/runtime/error/hooks";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
+const _parsedPort = Number.parseInt(process.env.NITRO_PORT ?? process.env.PORT ?? "");
+const port = Number.isNaN(_parsedPort) ? 3e3 : _parsedPort;
+const host = process.env.NITRO_HOST || process.env.HOST;
+const cert = process.env.NITRO_SSL_CERT;
+const key = process.env.NITRO_SSL_KEY;
+// const socketPath = process.env.NITRO_UNIX_SOCKET; // TODO
+const clusterId = cluster.isWorker && process.env.WORKER_ID;
+if (clusterId) {
+	console.log(`Worker #${clusterId} started`);
+}
+const nitroApp = useNitroApp();
+const server = serve({
+	port,
+	hostname: host,
+	tls: cert && key ? {
+		cert,
+		key
+	} : undefined,
+	node: { exclusive: false },
+	silent: clusterId ? clusterId !== "1" : undefined,
+	fetch: nitroApp.fetch
+});
+if (import.meta._websocket) {
+	const { handleUpgrade } = wsAdapter({ resolve: resolveWebsocketHooks });
+	server.node.server.on("upgrade", (req, socket, head) => {
+		handleUpgrade(
+			req,
+			socket,
+			head,
+			// @ts-expect-error (upgrade is not typed)
+			new NodeRequest({
+				req,
+				upgrade: {
+					socket,
+					head
+				}
+			})
+		);
+	});
+}
+trapUnhandledErrors();
+// Scheduled tasks
+if (import.meta._tasks) {
+	startScheduleRunner({ waitUntil: server.waitUntil });
+}
+export default {};

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

@@ -0,0 +1,14 @@
+import "#nitro/virtual/polyfills";
+import { toNodeHandler } from "srvx/node";
+import wsAdapter from "crossws/adapters/node";
+import { useNitroApp } from "nitro/app";
+import { startScheduleRunner } from "#nitro/runtime/task";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
+const nitroApp = useNitroApp();
+export const middleware = toNodeHandler(nitroApp.fetch);
+const ws = import.meta._websocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
+export const handleUpgrade = ws?.handleUpgrade;
+// Scheduled tasks
+if (import.meta._tasks) {
+	startScheduleRunner();
+}

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

@@ -0,0 +1,47 @@
+import "#nitro/virtual/polyfills";
+import { NodeRequest, serve } from "srvx/node";
+import wsAdapter from "crossws/adapters/node";
+import { useNitroApp } from "nitro/app";
+import { startScheduleRunner } from "#nitro/runtime/task";
+import { trapUnhandledErrors } from "#nitro/runtime/error/hooks";
+import { resolveWebsocketHooks } from "#nitro/runtime/app";
+const _parsedPort = Number.parseInt(process.env.NITRO_PORT ?? process.env.PORT ?? "");
+const port = Number.isNaN(_parsedPort) ? 3e3 : _parsedPort;
+const host = process.env.NITRO_HOST || process.env.HOST;
+const cert = process.env.NITRO_SSL_CERT;
+const key = process.env.NITRO_SSL_KEY;
+// const socketPath = process.env.NITRO_UNIX_SOCKET; // TODO
+const nitroApp = useNitroApp();
+const server = serve({
+	port,
+	hostname: host,
+	tls: cert && key ? {
+		cert,
+		key
+	} : undefined,
+	fetch: nitroApp.fetch
+});
+if (import.meta._websocket) {
+	const { handleUpgrade } = wsAdapter({ resolve: resolveWebsocketHooks });
+	server.node.server.on("upgrade", (req, socket, head) => {
+		handleUpgrade(
+			req,
+			socket,
+			head,
+			// @ts-expect-error (upgrade is not typed)
+			new NodeRequest({
+				req,
+				upgrade: {
+					socket,
+					head
+				}
+			})
+		);
+	});
+}
+trapUnhandledErrors();
+// Scheduled tasks
+if (import.meta._tasks) {
+	startScheduleRunner({ waitUntil: server.waitUntil });
+}
+export default {};