nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-121649-98b56dfe

package/dist/presets/_nitro/runtime/nitro-dev.mjs

@@ -7,53 +7,62 @@ import { parentPort, threadId } from "node:worker_threads";
 import wsAdapter from "crossws/adapters/node";
 import { toNodeHandler } from "srvx/node";
 import { getSocketAddress, isSocketSupported } from "get-port-please";
+// Trap unhandled errors
 trapUnhandledNodeErrors();
+// Listen for shutdown signal from runner
 parentPort?.on("message", (msg) => {
-  if (msg && msg.event === "shutdown") {
-    shutdown();
-  }
+	if (msg && msg.event === "shutdown") {
+		shutdown();
+	}
 });
 const nitroApp = useNitroApp();
 const nitroHooks = useNitroHooks();
 const server = new Server(toNodeHandler(nitroApp.fetch));
 let listener;
 listen().catch((error) => {
-  console.error("Dev worker failed to listen:", error);
-  return shutdown();
+	console.error("Dev worker failed to listen:", error);
+	return shutdown();
 });
+// https://crossws.unjs.io/adapters/node
 if (import.meta._websocket) {
-  const { handleUpgrade } = wsAdapter(nitroApp.h3App.websocket);
-  server.on("upgrade", handleUpgrade);
+	// @ts-expect-error
+	const { handleUpgrade } = wsAdapter(nitroApp.h3App.websocket);
+	server.on("upgrade", handleUpgrade);
 }
+// Scheduled tasks
 if (import.meta._tasks) {
-  startScheduleRunner();
+	startScheduleRunner();
 }
+// --- utils ---
 async function listen() {
-  const listenAddr = await isSocketSupported() ? getSocketAddress({
-    name: `nitro-dev-${threadId}`,
-    pid: true,
-    random: true
-  }) : { port: 0, host: "localhost" };
-  return new Promise((resolve, reject) => {
-    try {
-      listener = server.listen(listenAddr, () => {
-        const address = server.address();
-        parentPort?.postMessage({
-          event: "listen",
-          address: typeof address === "string" ? { socketPath: address } : { host: "localhost", port: address?.port }
-        });
-        resolve();
-      });
-    } catch (error) {
-      reject(error);
-    }
-  });
+	const listenAddr = await isSocketSupported() ? getSocketAddress({
+		name: `nitro-dev-${threadId}`,
+		pid: true,
+		random: true
+	}) : {
+		port: 0,
+		host: "localhost"
+	};
+	return new Promise((resolve, reject) => {
+		try {
+			listener = server.listen(listenAddr, () => {
+				const address = server.address();
+				parentPort?.postMessage({
+					event: "listen",
+					address: typeof address === "string" ? { socketPath: address } : {
+						host: "localhost",
+						port: address?.port
+					}
+				});
+				resolve();
+			});
+		} catch (error) {
+			reject(error);
+		}
+	});
 }
 async function shutdown() {
-  server.closeAllConnections?.();
-  await Promise.all([
-    new Promise((resolve) => listener?.close(resolve)),
-    nitroHooks.callHook("close")
-  ]).catch(console.error);
-  parentPort?.postMessage({ event: "exit" });
+	server.closeAllConnections?.();
+	await Promise.all([new Promise((resolve) => listener?.close(resolve)), nitroHooks.callHook("close")]).catch(console.error);
+	parentPort?.postMessage({ event: "exit" });
 }

package/dist/presets/_nitro/runtime/nitro-prerenderer.d.mts

@@ -1,3 +1,3 @@
 import "#nitro-internal-pollyfills";
-export declare const appFetch: any;
-export declare const closePrerenderer: () => any;
+export declare const appFetch: unknown;
+export declare const closePrerenderer: unknown;

package/dist/presets/_nitro/runtime/nitro-prerenderer.mjs

@@ -7,13 +7,9 @@ const nitroHooks = useNitroHooks();
 export const appFetch = nitroApp.request;
 export const closePrerenderer = () => nitroHooks.callHook("close");
 nitroHooks.hook("error", (error, context) => {
-  if (!error.unhandled && error.status >= 500 && context.event?.req?.headers instanceof Headers && context.event.req.headers.get("x-nitro-prerender")) {
-    consola.error(
-      `[prerender error]`,
-      `[${context.event.req.method}]`,
-      `[${context.event.req.url}]`,
-      error
-    );
-  }
+	if (!error.unhandled && error.status >= 500 && context.event?.req?.headers instanceof Headers && context.event.req.headers.get("x-nitro-prerender")) {
+		consola.error(`[prerender error]`, `[${context.event.req.method}]`, `[${context.event.req.url}]`, error);
+	}
 });
+// Trap unhandled errors
 trapUnhandledNodeErrors();

package/dist/presets/_nitro/runtime/service-worker.d.mts

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

package/dist/presets/_nitro/runtime/service-worker.mjs

@@ -2,20 +2,23 @@ import "#nitro-internal-pollyfills";
 import { useNitroApp } from "nitro/runtime";
 import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
 const nitroApp = useNitroApp();
+// @ts-expect-error
 addEventListener("fetch", (event) => {
-  const url = new URL(event.request.url);
-  if (isPublicAssetURL(url.pathname) || url.pathname.includes("/_server/")) {
-    return;
-  }
-  const req = event.request;
-  req.runtime ??= { name: "service-worker" };
-  req.runtime.serviceWorker ??= { event };
-  req.waitUntil = event.waitUntil.bind(event);
-  event.respondWith(nitroApp.fetch(req));
+	const url = new URL(event.request.url);
+	if (isPublicAssetURL(url.pathname) || url.pathname.includes("/_server/")) {
+		return;
+	}
+	// srvx compatibility
+	const req = event.request;
+	req.runtime ??= { name: "service-worker" };
+	// @ts-expect-error (add to srvx types)
+	req.runtime.serviceWorker ??= { event };
+	req.waitUntil = event.waitUntil.bind(event);
+	event.respondWith(nitroApp.fetch(req));
 });
 self.addEventListener("install", () => {
-  self.skipWaiting();
+	self.skipWaiting();
 });
 self.addEventListener("activate", (event) => {
-  event.waitUntil(self.clients.claim());
+	event.waitUntil(self.clients.claim());
 });

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

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

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

@@ -4,10 +4,11 @@ import { Server } from "node:http";
 import { toNodeHandler } from "srvx/node";
 const nitroApp = useNitroApp();
 const server = new Server(toNodeHandler(nitroApp.fetch));
+// @ts-ignore
 server.listen(3e3, (err) => {
-  if (err) {
-    console.error(err);
-  } else {
-    console.log(`Listening on http://localhost:3000 (AWS Amplify Hosting)`);
-  }
+	if (err) {
+		console.error(err);
+	} else {
+		console.log(`Listening on http://localhost:3000 (AWS Amplify Hosting)`);
+	}
 });

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

@@ -1,18 +1,13 @@
 import type { APIGatewayProxyEvent, APIGatewayProxyEventV2 } from "aws-lambda";
 import type { ServerRequest } from "srvx";
+// Incoming (AWS => Web)
 export declare function awsRequest(event: APIGatewayProxyEvent | APIGatewayProxyEventV2, context: unknown): ServerRequest;
-export declare function awsResponseHeaders(response: Response): {
-    headers: any;
-    cookies: string[];
-    multiValueHeaders: {
-        "set-cookie": string[];
-    };
-} | {
-    headers: any;
-    cookies?: undefined;
-    multiValueHeaders?: undefined;
-};
+// Outgoing (Web => AWS)
+export declare function awsResponseHeaders(response: Response);
+// AWS Lambda proxy integrations requires base64 encoded buffers
+// binaryMediaTypes should be */*
+// see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-payload-encodings.html
 export declare function awsResponseBody(response: Response): Promise<{
-    body: string;
-    isBase64Encoded?: boolean;
+	body: string;
+	isBase64Encoded?: boolean;
 }>;

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

@@ -1,102 +1,116 @@
 import { stringifyQuery } from "ufo";
+// Incoming (AWS => Web)
 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 });
+	const method = awsEventMethod(event);
+	const url = awsEventURL(event);
+	const headers = awsEventHeaders(event);
+	const body = awsEventBody(event);
+	const req = new Request(url, {
+		method,
+		headers,
+		body
+	});
+	// srvx compatibility
+	req.runtime ??= { name: "aws-lambda" };
+	// @ts-expect-error (add to srvx types)
+	req.runtime.aws ??= {
+		event,
+		context
+	};
+	return new Request(url, {
+		method,
+		headers,
+		body
+	});
 }
 function awsEventMethod(event) {
-  return event.httpMethod || event.requestContext?.http?.method || "GET";
+	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}`
-  );
+	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);
+	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;
+	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;
+	if (!event.body) {
+		return undefined;
+	}
+	if (event.isBase64Encoded) {
+		return Buffer.from(event.body || "", "base64");
+	}
+	return event.body;
 }
+// Outgoing (Web => AWS)
 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 };
+	const headers = 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,
+		multiValueHeaders: { "set-cookie": cookies }
+	} : { headers };
 }
+// AWS Lambda proxy integrations requires base64 encoded buffers
+// binaryMediaTypes should be */*
+// see https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-payload-encodings.html
 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 };
+	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);
+	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);
-  });
+	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

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

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

@@ -2,32 +2,30 @@ 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();
-    }
-  }
-);
+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();
+	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.mjs

@@ -3,11 +3,11 @@ 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)
-  };
+	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.mjs

@@ -1,50 +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;
+	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 !== void 0) {
-    return expiresAsNumber;
-  }
-  const expiresAsDate = new Date(expires);
-  if (!Number.isNaN(expiresAsDate.getTime())) {
-    return expiresAsDate;
-  }
+	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 void 0;
-  }
-  const maxAgeAsNumber = Number(maxAge);
-  if (!Number.isNaN(maxAgeAsNumber)) {
-    return maxAgeAsNumber;
-  }
+	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.d.mts

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

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

@@ -4,25 +4,26 @@ 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.request(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")
-    )
-  };
+	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 response = await nitroApp.request(url, {
+		method: req.method || undefined,
+		body: req.bufferBody ?? req.rawBody
+	});
+	// (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"))
+	};
 }