nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-121649-98b56dfe

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

@@ -1,21 +1,21 @@
 import "#nitro-internal-pollyfills";
 import type { Handler } from "aws-lambda";
 type StormkitEvent = {
-    url: string;
-    path: string;
-    method: string;
-    body?: string;
-    query?: Record<string, Array<string>>;
-    headers?: Record<string, string>;
-    rawHeaders?: Array<string>;
+	url: string;
+	path: string;
+	method: string;
+	body?: string;
+	query?: Record<string, Array<string>>;
+	headers?: Record<string, string>;
+	rawHeaders?: Array<string>;
 };
 type StormkitResponse = {
-    headers?: Record<string, string>;
-    body?: string;
-    buffer?: string;
-    statusCode: number;
-    errorMessage?: string;
-    errorStack?: string;
+	headers?: Record<string, string>;
+	body?: string;
+	buffer?: string;
+	statusCode: number;
+	errorMessage?: string;
+	errorStack?: string;
 };
 export declare const handler: Handler<StormkitEvent, StormkitResponse>;
 export {};

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

@@ -3,26 +3,26 @@ import { useNitroApp } from "nitro/runtime";
 import { awsResponseBody } from "../../aws-lambda/runtime/_utils.mjs";
 const nitroApp = useNitroApp();
 export const handler = async function(event, context) {
-  const req = new Request(event.url, {
-    method: event.method || "GET",
-    headers: event.headers,
-    body: event.body
-  });
-  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),
-    [isBase64Encoded ? "buffer" : "body"]: body
-  };
+	const req = new Request(event.url, {
+		method: event.method || "GET",
+		headers: event.headers,
+		body: event.body
+	});
+	// srvx compatibility
+	req.runtime ??= { name: "stormkit" };
+	// @ts-expect-error (add to srvx types)
+	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),
+		[isBase64Encoded ? "buffer" : "body"]: body
+	};
 };
 function normalizeOutgoingHeaders(headers) {
-  return Object.fromEntries(
-    Object.entries(headers).map(([k, v]) => [
-      k,
-      Array.isArray(v) ? v.join(",") : String(v)
-    ])
-  );
+	return Object.fromEntries(Object.entries(headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(",") : String(v)]));
 }

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

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

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

@@ -1,17 +1,18 @@
 import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
 const nitroApp = useNitroApp();
-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);
-  }
-};
+export default { fetch(req, context) {
+	// Check for ISR request
+	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);
+	}
+	// srvx compatibility
+	req.runtime ??= { name: "vercel" };
+	// @ts-expect-error (add to srvx types)
+	req.runtime.vercel = { context };
+	req.waitUntil = context?.waitUntil;
+	return nitroApp.fetch(req);
+} };

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

@@ -1 +1,3 @@
+// @ts-nocheck TODO: Remove after removing polyfills
 import "#nitro-internal-pollyfills";
+export {};

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

@@ -1,87 +1,91 @@
+// @ts-nocheck TODO: Remove after removing polyfills
 import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
 import { hasProtocol, joinURL } from "ufo";
 const nitroApp = useNitroApp();
+// Use plain handler as winterjs Web API is incomplete
+// TODO: Migrate to toWebHandler
 const _handler = toPlainHandler(nitroApp.h3App);
 async function _handleEvent(event) {
-  try {
-    const res = await _handler({
-      path: event.request.url.pathname + (event.request.url.search ? `?${event.request.url.search}` : ""),
-      method: event.request.getMethod() || "GET",
-      body: event.request.body,
-      headers: event.request.headers,
-      context: {
-        waitUntil: (promise) => event.waitUntil(promise),
-        _platform: {
-          winterjs: {
-            event
-          }
-        }
-      }
-    });
-    const body = typeof res.body === "string" ? res.body : await toBuffer(res.body);
-    return new Response(body, {
-      status: res.status,
-      statusText: res.statusText,
-      headers: res.headers
-    });
-  } catch (error) {
-    const errString = error?.message + "\n" + error?.stack;
-    console.error(errString);
-    return new Response(errString, { status: 500 });
-  }
+	try {
+		const res = await _handler({
+			path: event.request.url.pathname + (event.request.url.search ? `?${event.request.url.search}` : ""),
+			method: event.request.getMethod() || "GET",
+			body: event.request.body,
+			headers: event.request.headers,
+			context: {
+				waitUntil: (promise) => event.waitUntil(promise),
+				_platform: { winterjs: { event } }
+			}
+		});
+		const body = typeof res.body === "string" ? res.body : await toBuffer(res.body);
+		return new Response(body, {
+			status: res.status,
+			statusText: res.statusText,
+			headers: res.headers
+		});
+	} catch (error) {
+		const errString = error?.message + "\n" + error?.stack;
+		console.error(errString);
+		return new Response(errString, { status: 500 });
+	}
 }
 addEventListener("fetch", async (event) => {
-  event.respondWith(await _handleEvent(event));
+	event.respondWith(await _handleEvent(event));
 });
+// ------------------------------
+// Polyfills for missing APIs
+// ------------------------------
 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);
-  });
+	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);
+	});
 }
+// Headers.entries
 if (!Headers.prototype.entries) {
-  Headers.prototype.entries = function() {
-    return [...this];
-  };
+	// @ts-ignore
+	Headers.prototype.entries = function() {
+		return [...this];
+	};
 }
+// URL.pathname
 if (!URL.prototype.pathname) {
-  Object.defineProperty(URL.prototype, "pathname", {
-    get() {
-      return this.path || "/";
-    }
-  });
+	Object.defineProperty(URL.prototype, "pathname", { get() {
+		return this.path || "/";
+	} });
 }
+// URL constructor (relative support)
 const _URL = globalThis.URL;
-globalThis.URL = class URL2 extends _URL {
-  constructor(url, base) {
-    if (!base || hasProtocol(url)) {
-      super(url);
-      return;
-    }
-    super(joinURL(base, url));
-  }
+globalThis.URL = class URL extends _URL {
+	constructor(url, base) {
+		if (!base || hasProtocol(url)) {
+			super(url);
+			return;
+		}
+		super(joinURL(base, url));
+	}
 };
+// Response (avoid Promise body)
 const _Response = globalThis.Response;
-globalThis.Response = class Response2 extends _Response {
-  _body;
-  constructor(body, init) {
-    super(body, init);
-    this._body = body;
-  }
-  get body() {
-    return this._body;
-  }
+globalThis.Response = class Response extends _Response {
+	_body;
+	constructor(body, init) {
+		super(body, init);
+		this._body = body;
+	}
+	get body() {
+		// TODO: Return ReadableStream (should be iterable)
+		return this._body;
+	}
 };

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

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

package/dist/runtime/index.d.mts

@@ -1,11 +1,22 @@
+// Public API (also exposed as auto-imports defined in core/imports.ts)
+// Type (only) helpers
 export { defineNitroPlugin } from "./internal/plugin.mjs";
 export { defineRouteMeta } from "./internal/meta.mjs";
 export { defineNitroErrorHandler } from "./internal/error/utils.mjs";
+// Config
 export { useRuntimeConfig } from "./internal/runtime-config.mjs";
+// Context
 export { useRequest } from "./internal/context.mjs";
+// Renderer
 export { defineRenderHandler } from "./internal/renderer.mjs";
-export { defineCachedFunction, defineCachedEventHandler, defineCachedHandler, cachedFunction, cachedEventHandler, } from "./internal/cache.mjs";
-export { useNitroApp } from "./internal/app.mjs";
+// Cache
+export { defineCachedFunction, defineCachedEventHandler, defineCachedHandler, cachedFunction, cachedEventHandler } from "./internal/cache.mjs";
+// ---- Internals that depends on virtual imports should come last ---- //
+// App
+export { useNitroApp, useNitroHooks } from "./internal/app.mjs";
+// Storage
 export { useStorage } from "./internal/storage.mjs";
+// Database
 export { useDatabase } from "./internal/database.mjs";
+// Tasks
 export { defineTask, runTask } from "./internal/task.mjs";

package/dist/runtime/index.mjs

@@ -1,17 +1,22 @@
+// Public API (also exposed as auto-imports defined in core/imports.ts)
+// Type (only) helpers
 export { defineNitroPlugin } from "./internal/plugin.mjs";
 export { defineRouteMeta } from "./internal/meta.mjs";
 export { defineNitroErrorHandler } from "./internal/error/utils.mjs";
+// Config
 export { useRuntimeConfig } from "./internal/runtime-config.mjs";
+// Context
 export { useRequest } from "./internal/context.mjs";
+// Renderer
 export { defineRenderHandler } from "./internal/renderer.mjs";
-export {
-  defineCachedFunction,
-  defineCachedEventHandler,
-  defineCachedHandler,
-  cachedFunction,
-  cachedEventHandler
-} from "./internal/cache.mjs";
-export { useNitroApp } from "./internal/app.mjs";
+// Cache
+export { defineCachedFunction, defineCachedEventHandler, defineCachedHandler, cachedFunction, cachedEventHandler } from "./internal/cache.mjs";
+// ---- Internals that depends on virtual imports should come last ---- //
+// App
+export { useNitroApp, useNitroHooks } from "./internal/app.mjs";
+// Storage
 export { useStorage } from "./internal/storage.mjs";
+// Database
 export { useDatabase } from "./internal/database.mjs";
+// Tasks
 export { defineTask, runTask } from "./internal/task.mjs";

package/dist/runtime/internal/app.d.mts

@@ -1,2 +1,4 @@
-import type { NitroApp } from "nitro/types";
+import type { NitroApp, NitroRuntimeHooks } from "nitro/types";
+import { HookableCore } from "hookable";
 export declare function useNitroApp(): NitroApp;
+export declare function useNitroHooks(): HookableCore<NitroRuntimeHooks>;