nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-122334-09c1a7a8

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

@@ -1 +1,2 @@
 import "#nitro-internal-pollyfills";
+export {};

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

@@ -3,25 +3,26 @@ 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 ws = import.meta._websocket ? wsAdapter(nitroApp.h3App.websocket) : undefined;
+// @ts-expect-error
 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);
-  }
+	port: process.env.NITRO_PORT || process.env.PORT || 3e3,
+	hostname: process.env.NITRO_HOST || process.env.HOST,
+	websocket: import.meta._websocket ? ws.websocket : undefined,
+	async fetch(bunReq, server) {
+		// srvx compatibility
+		const req = bunReq;
+		req.runtime ??= { name: "bun" };
+		req.runtime.bun ??= { server };
+		// https://crossws.unjs.io/adapters/bun
+		if (import.meta._websocket && req.headers.get("upgrade") === "websocket") {
+			return ws.handleUpgrade(req, server);
+		}
+		return nitroApp.fetch(req);
+	}
 });
 console.log(`Listening on ${server.url}...`);
+// Scheduled tasks
 if (import.meta._tasks) {
-  startScheduleRunner();
+	startScheduleRunner();
 }

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

@@ -3,11 +3,14 @@ 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>;
+	fetch: (...params: [...Parameters<NonNullable<ExportedHandler<Env>["fetch"]>>, url: URL, cfContextExtras: any]) => MaybePromise<Response | CF.Response | undefined>;
+}): {
+	fetch(request, env, context);
+	scheduled(controller, env, context);
+	email(message, env, context);
+	queue(batch, env, context);
+	tail(traces, env, context);
+	trace(traces, env, context);
+};
+export declare function fetchHandler(cfReq: Request | CF.Request, env: unknown, context: CF.ExecutionContext | DurableObjectState, url: URL, nitroApp, ctxExt: any);
 export {};

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

@@ -2,93 +2,84 @@ import "#nitro-internal-pollyfills";
 import { useNitroApp, useNitroHooks } from "nitro/runtime";
 import { runCronTasks } from "nitro/runtime/internal";
 export function createHandler(hooks) {
-  const nitroApp = useNitroApp();
-  const nitroHooks = useNitroHooks();
-  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(
-        nitroHooks.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(
-        nitroHooks.callHook("cloudflare:email", {
-          message,
-          event: message,
-          // backward compat
-          env,
-          context
-        })
-      );
-    },
-    queue(batch, env, context) {
-      globalThis.__env__ = env;
-      context.waitUntil(
-        nitroHooks.callHook("cloudflare:queue", {
-          batch,
-          event: batch,
-          env,
-          context
-        })
-      );
-    },
-    tail(traces, env, context) {
-      globalThis.__env__ = env;
-      context.waitUntil(
-        nitroHooks.callHook("cloudflare:tail", {
-          traces,
-          env,
-          context
-        })
-      );
-    },
-    trace(traces, env, context) {
-      globalThis.__env__ = env;
-      context.waitUntil(
-        nitroHooks.callHook("cloudflare:trace", {
-          traces,
-          env,
-          context
-        })
-      );
-    }
-  };
+	const nitroApp = useNitroApp();
+	const nitroHooks = useNitroHooks();
+	return {
+		async fetch(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 fetchHandler(request, env, context, url, nitroApp, ctxExt);
+		},
+		scheduled(controller, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.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(nitroHooks.callHook("cloudflare:email", {
+				message,
+				event: message,
+				env,
+				context
+			}));
+		},
+		queue(batch, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:queue", {
+				batch,
+				event: batch,
+				env,
+				context
+			}));
+		},
+		tail(traces, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.callHook("cloudflare:tail", {
+				traces,
+				env,
+				context
+			}));
+		},
+		trace(traces, env, context) {
+			globalThis.__env__ = env;
+			context.waitUntil(nitroHooks.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);
+	// Expose latest env to the global context
+	globalThis.__env__ = env;
+	// srvx compatibility
+	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

@@ -1,19 +1,11 @@
 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>;
+declare const _default;
 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>;
+	constructor(state: DurableObjectState, env: Record<string, any>);
+	fetch(request: Request);
+	alarm(): void | Promise<void>;
+	webSocketMessage(client: WebSocket, message: ArrayBuffer | string);
+	webSocketClose(client: WebSocket, code: number, reason: string, wasClean: boolean);
 }

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

@@ -9,65 +9,60 @@ 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 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);
-    }
-  }
-});
+	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
-      })
-    );
-    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(nitroHooks.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);
-    }
-  }
+	constructor(state, env) {
+		super(state, env);
+		state.waitUntil(nitroHooks.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);
+		}
+		// Main handler
+		const url = new URL(request.url);
+		return fetchHandler(request, this.env, this.ctx, url, nitroApp, { durable: this });
+	}
+	alarm() {
+		this.ctx.waitUntil(nitroHooks.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

@@ -1,9 +1,3 @@
 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>;
+declare const _default;
 export default _default;

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

@@ -4,17 +4,15 @@ 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);
-    }
-  }
-});
+const ws = import.meta._websocket ? wsAdapter(nitroApp.h3App.websocket) : undefined;
+export default createHandler({ fetch(request, env, context, url) {
+	// Static assets fallback (optional binding)
+	if (env.ASSETS && isPublicAssetURL(url.pathname)) {
+		return env.ASSETS.fetch(request);
+	}
+	// Websocket upgrade
+	// https://crossws.unjs.io/adapters/cloudflare
+	if (import.meta._websocket && request.headers.get("upgrade") === "websocket") {
+		return ws.handleUpgrade(request, env, context);
+	}
+} });

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

@@ -1,20 +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
- */
+* 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;
+	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;
+	fetch(cfReq: CFRequest, env: CFPagesEnv, context: EventContext<CFPagesEnv, string, any>);
+	scheduled(event: any, env: CFPagesEnv, context: ExecutionContext);
 };
 export default _default;

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

@@ -4,44 +4,40 @@ 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;
+const ws = import.meta._websocket ? wsAdapter(nitroApp.h3App.websocket) : undefined;
 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: {}
-        })
-      );
-    }
-  }
+	async fetch(cfReq, env, context) {
+		// srvx compatibility
+		const req = cfReq;
+		req.runtime ??= { name: "cloudflare" };
+		req.runtime.cloudflare ??= {
+			context,
+			env
+		};
+		req.waitUntil = context.waitUntil.bind(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);
+		}
+		// Expose latest env to the global context
+		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

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