vinext 1.0.0-beta.8 → 1.0.0

package/dist/server/opentelemetry-api.d.ts

@@ -0,0 +1,59 @@
+//#region src/server/opentelemetry-api.d.ts
+/**
+ * The OpenTelemetry API stores its registered context, propagation, and trace
+ * APIs in a versioned global registry. Reading that registry lets vinext join
+ * an application-owned provider without requiring OpenTelemetry to be
+ * installed alongside vinext itself.
+ */
+type OpenTelemetryContext = {
+  deleteValue(key: symbol): OpenTelemetryContext;
+  getValue(key: symbol): unknown;
+  setValue(key: symbol, value: unknown): OpenTelemetryContext;
+};
+export type OpenTelemetrySpan = {
+  end(): void;
+  isRecording(): boolean;
+  recordException(error: unknown): void;
+  setAttribute(key: string, value: OpenTelemetryAttributeValue): void;
+  setStatus(status: {
+    code: number;
+    message?: string;
+  }): void;
+  spanContext(): unknown;
+  updateName(name: string): void;
+};
+export type OpenTelemetryTracer = {
+  startActiveSpan<T>(name: string, options: {
+    attributes: Record<string, OpenTelemetryAttributeValue>;
+    kind?: number;
+  }, callback: (span: OpenTelemetrySpan) => T): T;
+  startSpan(...args: unknown[]): OpenTelemetrySpan;
+};
+type OpenTelemetryTracerProvider = {
+  getDelegate?: () => unknown;
+  getDelegateTracer?: (...args: unknown[]) => OpenTelemetryTracer | undefined;
+  getTracer(...args: [name: string, version?: string, options?: unknown]): OpenTelemetryTracer;
+};
+type OpenTelemetryAttributeValue = string | number | boolean | readonly string[] | readonly number[] | readonly boolean[];
+export type OpenTelemetryApi = {
+  context: {
+    active(): OpenTelemetryContext;
+    with<T>(context: OpenTelemetryContext, callback: () => T): T;
+  };
+  propagation: {
+    extract(context: OpenTelemetryContext, carrier: Headers, getter: {
+      get(carrier: Headers, key: string): string | undefined;
+      keys(carrier: Headers): string[];
+    }): OpenTelemetryContext;
+  };
+  trace: {
+    getSpan(context: OpenTelemetryContext): OpenTelemetrySpan | undefined;
+    getSpanContext(context: OpenTelemetryContext): unknown;
+    getTracer(name: string, version?: string): OpenTelemetryTracer;
+    getTracerProvider(): OpenTelemetryTracerProvider;
+  };
+};
+export declare function getOpenTelemetryRootContext(): OpenTelemetryContext;
+/** Resolve the API registered by the application, if any. */
+export declare function getOpenTelemetryApi(): OpenTelemetryApi | undefined;
+//#endregion

package/dist/server/opentelemetry-api.js

@@ -0,0 +1,53 @@
+//#region src/server/opentelemetry-api.ts
+const OPEN_TELEMETRY_API_SYMBOL = Symbol.for("opentelemetry.js.api.1");
+const OPEN_TELEMETRY_SPAN_SYMBOL = Symbol.for("OpenTelemetry Context Key SPAN");
+const ROOT_CONTEXT = new class RootContext {
+	values;
+	constructor(values = /* @__PURE__ */ new Map()) {
+		this.values = values;
+	}
+	deleteValue(key) {
+		const values = new Map(this.values);
+		values.delete(key);
+		return new RootContext(values);
+	}
+	getValue(key) {
+		return this.values.get(key);
+	}
+	setValue(key, value) {
+		const values = new Map(this.values);
+		values.set(key, value);
+		return new RootContext(values);
+	}
+}();
+function getOpenTelemetryRootContext() {
+	return ROOT_CONTEXT;
+}
+function apiFromRegistry(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const registry = value;
+	const provider = registry.trace;
+	if (typeof provider?.getTracer !== "function") return void 0;
+	return {
+		context: {
+			active: () => registry.context?.active() ?? ROOT_CONTEXT,
+			with: (context, callback) => registry.context ? registry.context.with(context, callback) : callback()
+		},
+		propagation: { extract: (context, carrier, getter) => registry.propagation?.extract(context, carrier, getter) ?? context },
+		trace: {
+			getSpan: (context) => context.getValue(OPEN_TELEMETRY_SPAN_SYMBOL),
+			getSpanContext: (context) => {
+				return context.getValue(OPEN_TELEMETRY_SPAN_SYMBOL)?.spanContext();
+			},
+			getTracer: (name, version) => provider.getTracer(name, version),
+			getTracerProvider: () => provider
+		}
+	};
+}
+/** Resolve the API registered by the application, if any. */
+function getOpenTelemetryApi() {
+	const registered = globalThis[OPEN_TELEMETRY_API_SYMBOL];
+	return apiFromRegistry(registered);
+}
+//#endregion
+export { getOpenTelemetryApi, getOpenTelemetryRootContext };

package/dist/server/opentelemetry-tracing.d.ts

@@ -0,0 +1,5 @@
+import { FrameworkTracingIntegration } from "./framework-tracer.js";
+//#region src/server/opentelemetry-tracing.d.ts
+/** Standard OpenTelemetry backend using the provider registered by the app. */
+export declare const openTelemetryTracingIntegration: FrameworkTracingIntegration;
+//#endregion

package/dist/server/opentelemetry-tracing.js

@@ -0,0 +1,83 @@
+import { getOpenTelemetryApi, getOpenTelemetryRootContext } from "./opentelemetry-api.js";
+import { isPromiseLike } from "../utils/promise.js";
+//#region src/server/opentelemetry-tracing.ts
+const headersGetter = {
+	get(carrier, key) {
+		return carrier.get(key) ?? void 0;
+	},
+	keys(carrier) {
+		return [...carrier.keys()];
+	}
+};
+const spanKinds = {
+	client: 2,
+	internal: 0,
+	server: 1
+};
+function isEnabled(api) {
+	if (api.trace.getSpan(api.context.active())?.isRecording()) return true;
+	const provider = api.trace.getTracerProvider();
+	if (!("getDelegate" in provider)) return true;
+	return (provider.getDelegate?.())?.constructor?.name !== "NoopTracerProvider";
+}
+function backendSpan(span) {
+	return {
+		recordException: (error) => span.recordException(error),
+		setAttribute: (key, value) => span.setAttribute(key, value),
+		setErrorStatus: (message) => span.setStatus({
+			code: 2,
+			message
+		}),
+		updateName: (name) => span.updateName(name)
+	};
+}
+const noopSpan = { setAttribute() {} };
+/** Standard OpenTelemetry backend using the provider registered by the app. */
+const openTelemetryTracingIntegration = {
+	captureActiveContext() {
+		const api = getOpenTelemetryApi();
+		const context = api?.context.active();
+		return (callback) => api && context ? api.context.with(context, callback) : callback();
+	},
+	getActiveSpan() {
+		const api = getOpenTelemetryApi();
+		const span = api?.trace.getSpan(api.context.active());
+		return span ? backendSpan(span) : void 0;
+	},
+	id: "opentelemetry",
+	enterSpan(descriptor, callback) {
+		const api = getOpenTelemetryApi();
+		if (!api || !isEnabled(api)) return callback(noopSpan);
+		return api.trace.getTracer("next.js", "0.0.1").startActiveSpan(descriptor.name, {
+			attributes: descriptor.attributes,
+			kind: spanKinds[descriptor.kind]
+		}, (span) => {
+			try {
+				const result = callback(backendSpan(span));
+				if (!isPromiseLike(result)) {
+					span.end();
+					return result;
+				}
+				return Promise.resolve(result).finally(() => span.end());
+			} catch (error) {
+				span.end();
+				throw error;
+			}
+		});
+	},
+	runWithDetachedContext(callback) {
+		const api = getOpenTelemetryApi();
+		return api ? api.context.with(getOpenTelemetryRootContext(), callback) : callback();
+	},
+	withPropagatedContext(carrier, callback) {
+		const api = getOpenTelemetryApi();
+		if (!api) return callback();
+		const active = api.context.active();
+		if (!isEnabled(api) && !api.trace.getSpanContext(active)) return callback();
+		if (api.trace.getSpanContext(active)) return callback();
+		const extracted = api.propagation.extract(active, carrier, headersGetter);
+		return api.context.with(extracted, callback);
+	}
+};
+//#endregion
+export { openTelemetryTracingIntegration };

package/dist/server/operation-token.d.ts

@@ -1,6 +1,6 @@
 //#region src/server/operation-token.d.ts
-type OperationLane = "hmr" | "navigation" | "prefetch" | "refresh" | "server-action" | "traverse";
-type OperationToken = {
+export type OperationLane = "hmr" | "navigation" | "prefetch" | "refresh" | "server-action" | "traverse";
+export type OperationToken = {
   operationId: number;
   lane: OperationLane;
   navigationId: number;
@@ -11,30 +11,29 @@ type OperationToken = {
   cacheVariantFingerprint?: string;
 };
 declare const verifiedOperationTokenBrand: unique symbol;
-type VerifiedOperationToken = OperationToken & {
+export type VerifiedOperationToken = OperationToken & {
   readonly [verifiedOperationTokenBrand]: true;
 };
-type OperationTokenAuthority = {
+export type OperationTokenAuthority = {
   activeNavigationId: number;
   visibleCommitVersion: number;
   graphVersion: string | null;
   installedCacheVariantFingerprint: string | null;
 };
 type OperationTokenDimension = "navigation" | "visibleCommit" | "graphVersion" | "cacheVariant";
-type OperationTokenRejectionReason = "staleNavigation" | "staleVisibleCommit" | "graphVersionMismatch" | "graphVersionMissing" | "cacheVariantMismatch" | "cacheVariantMissing";
-type OperationTokenVerdict = {
+export type OperationTokenRejectionReason = "staleNavigation" | "staleVisibleCommit" | "graphVersionMismatch" | "graphVersionMissing" | "cacheVariantMismatch" | "cacheVariantMissing";
+export type OperationTokenVerdict = {
   readonly authorized: true;
   readonly token: VerifiedOperationToken;
 } | {
   readonly authorized: false;
   readonly reason: OperationTokenRejectionReason;
 };
-type OperationTokenVerificationPolicy = {
+export type OperationTokenVerificationPolicy = {
   check: readonly OperationTokenDimension[];
   require: readonly OperationTokenDimension[];
 };
-declare function verifyOperationToken(token: OperationToken, authority: OperationTokenAuthority, policy: OperationTokenVerificationPolicy): OperationTokenVerdict;
-declare function verifyOperationTokenForCommit(token: OperationToken, authority: Pick<OperationTokenAuthority, "activeNavigationId" | "visibleCommitVersion">): OperationTokenVerdict;
-declare function verifyOperationTokenForCacheReuse(token: OperationToken, authority: Pick<OperationTokenAuthority, "graphVersion" | "installedCacheVariantFingerprint">): OperationTokenVerdict;
-//#endregion
-export { OperationLane, OperationToken, OperationTokenAuthority, OperationTokenRejectionReason, OperationTokenVerdict, OperationTokenVerificationPolicy, VerifiedOperationToken, verifyOperationToken, verifyOperationTokenForCacheReuse, verifyOperationTokenForCommit };
+export declare function verifyOperationToken(token: OperationToken, authority: OperationTokenAuthority, policy: OperationTokenVerificationPolicy): OperationTokenVerdict;
+export declare function verifyOperationTokenForCommit(token: OperationToken, authority: Pick<OperationTokenAuthority, "activeNavigationId" | "visibleCommitVersion">): OperationTokenVerdict;
+export declare function verifyOperationTokenForCacheReuse(token: OperationToken, authority: Pick<OperationTokenAuthority, "graphVersion" | "installedCacheVariantFingerprint">): OperationTokenVerdict;
+//#endregion

package/dist/server/otel-tracer-extension.d.ts

@@ -3,10 +3,9 @@
  * OpenTelemetry tracer provider extension for Cache Components.
  *
  * When `cacheComponents: true` is enabled in next.config, component renders
- * go through multiple phases (warmup → resume). During these phases, the
- * `workUnitAsyncStorage` carries a prerender or cache store. Without this
+ * run inside request, prerender, or cache work units. Without this
  * extension, calls to `tracer.startSpan()` / `tracer.startActiveSpan()` from
- * inside user RSC code would inherit that prerender context, causing:
+ * inside user RSC code would inherit that work-unit context, causing:
  *
  *  1. Spans to reuse the same trace ID across requests (the frozen prerender
  *     context bleeds into the runtime resume render).
@@ -21,8 +20,7 @@
  *    context restored.
  *
  * This extension is intentionally a no-op when:
- *  - `@opentelemetry/api` is not installed (graceful degradation).
- *  - No OTel tracer provider has been registered (provider is the noop provider).
+ *  - No compatible OpenTelemetry API has registered its process-wide global.
  *  - `workUnitAsyncStorage` has no active store (non-render contexts).
  *
  * References:
@@ -38,8 +36,8 @@
  * Safe to call multiple times — subsequent calls are no-ops once the provider
  * has been wrapped.
  *
- * Must only be called in Node.js environments (not Edge runtime).
+ * Safe in Node.js and Workers because it consumes only the application's
+ * standard OpenTelemetry global registry.
  */
-declare function extendTracerProviderForCacheComponents(): void;
-//#endregion
-export { extendTracerProviderForCacheComponents };
+export declare function extendTracerProviderForCacheComponents(): void;
+//#endregion

package/dist/server/otel-tracer-extension.js

@@ -1,13 +1,13 @@
 import { workUnitAsyncStorage } from "../shims/internal/work-unit-async-storage.js";
+import { getOpenTelemetryApi } from "./opentelemetry-api.js";
 //#region src/server/otel-tracer-extension.ts
 /**
 * OpenTelemetry tracer provider extension for Cache Components.
 *
 * When `cacheComponents: true` is enabled in next.config, component renders
-* go through multiple phases (warmup → resume). During these phases, the
-* `workUnitAsyncStorage` carries a prerender or cache store. Without this
+* run inside request, prerender, or cache work units. Without this
 * extension, calls to `tracer.startSpan()` / `tracer.startActiveSpan()` from
-* inside user RSC code would inherit that prerender context, causing:
+* inside user RSC code would inherit that work-unit context, causing:
 *
 *  1. Spans to reuse the same trace ID across requests (the frozen prerender
 *     context bleeds into the runtime resume render).
@@ -22,8 +22,7 @@ import { workUnitAsyncStorage } from "../shims/internal/work-unit-async-storage.
 *    context restored.
 *
 * This extension is intentionally a no-op when:
-*  - `@opentelemetry/api` is not installed (graceful degradation).
-*  - No OTel tracer provider has been registered (provider is the noop provider).
+*  - No compatible OpenTelemetry API has registered its process-wide global.
 *  - `workUnitAsyncStorage` has no active store (non-render contexts).
 *
 * References:
@@ -31,6 +30,7 @@ import { workUnitAsyncStorage } from "../shims/internal/work-unit-async-storage.
 *  - https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-utils/instrumentation-node-extensions.ts
 */
 const extendedProviders = /* @__PURE__ */ new WeakSet();
+const extendedTracers = /* @__PURE__ */ new WeakSet();
 const USE_CACHE_FUNCTION_SYMBOL = Symbol.for("vinext.useCacheFunction");
 function isUseCacheFn(fn) {
 	return typeof fn === "function" && fn[USE_CACHE_FUNCTION_SYMBOL] === true;
@@ -44,46 +44,47 @@ function isUseCacheFn(fn) {
 * Safe to call multiple times — subsequent calls are no-ops once the provider
 * has been wrapped.
 *
-* Must only be called in Node.js environments (not Edge runtime).
+* Safe in Node.js and Workers because it consumes only the application's
+* standard OpenTelemetry global registry.
 */
 function extendTracerProviderForCacheComponents() {
-	let api;
-	try {
-		const req = globalThis.require;
-		if (typeof req === "function") api = req("@opentelemetry/api");
-	} catch {
-		return;
-	}
+	const api = getOpenTelemetryApi();
 	if (!api) return;
 	const provider = api.trace.getTracerProvider();
-	if (!provider || typeof provider.getTracer !== "function") return;
 	if (extendedProviders.has(provider)) return;
 	extendedProviders.add(provider);
 	const originalGetTracer = provider.getTracer.bind(provider);
-	const wrappedTracers = /* @__PURE__ */ new WeakSet();
-	provider.getTracer = (...args) => {
-		const tracer = originalGetTracer(...args);
-		if (!tracer || wrappedTracers.has(tracer)) return tracer;
-		const originalStartSpan = tracer.startSpan;
-		if (typeof originalStartSpan === "function") tracer.startSpan = (...startSpanArgs) => workUnitAsyncStorage.exit(() => originalStartSpan.apply(tracer, startSpanArgs));
-		const originalStartActiveSpan = tracer.startActiveSpan;
-		if (typeof originalStartActiveSpan === "function") tracer.startActiveSpan = (...startActiveSpanArgs) => {
-			const workUnitStore = workUnitAsyncStorage.getStore();
-			if (!workUnitStore) return originalStartActiveSpan.apply(tracer, startActiveSpanArgs);
-			let fnIdx = 0;
-			if (startActiveSpanArgs.length === 2 && typeof startActiveSpanArgs[1] === "function") fnIdx = 1;
-			else if (startActiveSpanArgs.length === 3 && typeof startActiveSpanArgs[2] === "function") fnIdx = 2;
-			else if (startActiveSpanArgs.length > 3 && typeof startActiveSpanArgs[3] === "function") fnIdx = 3;
-			if (fnIdx > 0) {
-				const originalFn = startActiveSpanArgs[fnIdx];
-				if (isUseCacheFn(originalFn)) console.error("A Cache Function (`use cache`) was passed to startActiveSpan which means it will receive a Span argument with a possibly random ID on every invocation leading to cache misses. Provide a wrapping function around the Cache Function that does not forward the Span argument to avoid this issue.");
-				startActiveSpanArgs[fnIdx] = (...cbArgs) => workUnitAsyncStorage.run(workUnitStore, originalFn, ...cbArgs);
-			}
-			return workUnitAsyncStorage.exit(() => originalStartActiveSpan.apply(tracer, startActiveSpanArgs));
+	provider.getTracer = (...args) => instrumentTracer(originalGetTracer(...args));
+	if (typeof provider.getDelegateTracer === "function") {
+		const originalGetDelegateTracer = provider.getDelegateTracer.bind(provider);
+		provider.getDelegateTracer = (...args) => {
+			const tracer = originalGetDelegateTracer(...args);
+			return tracer ? instrumentTracer(tracer) : void 0;
 		};
-		wrappedTracers.add(tracer);
-		return tracer;
+	}
+}
+function instrumentTracer(tracer) {
+	if (extendedTracers.has(tracer)) return tracer;
+	const mutableTracer = tracer;
+	const originalStartSpan = mutableTracer.startSpan.bind(mutableTracer);
+	mutableTracer.startSpan = (...startSpanArgs) => workUnitAsyncStorage.exit(() => originalStartSpan(...startSpanArgs));
+	const originalStartActiveSpan = mutableTracer.startActiveSpan.bind(mutableTracer);
+	mutableTracer.startActiveSpan = (...startActiveSpanArgs) => {
+		const workUnitStore = workUnitAsyncStorage.getStore();
+		if (!workUnitStore) return originalStartActiveSpan(...startActiveSpanArgs);
+		let fnIdx = 0;
+		if (startActiveSpanArgs.length === 2 && typeof startActiveSpanArgs[1] === "function") fnIdx = 1;
+		else if (startActiveSpanArgs.length === 3 && typeof startActiveSpanArgs[2] === "function") fnIdx = 2;
+		else if (startActiveSpanArgs.length > 3 && typeof startActiveSpanArgs[3] === "function") fnIdx = 3;
+		if (fnIdx > 0) {
+			const originalFn = startActiveSpanArgs[fnIdx];
+			if (isUseCacheFn(originalFn)) console.error("A Cache Function (`use cache`) was passed to startActiveSpan which means it will receive a Span argument with a possibly random ID on every invocation leading to cache misses. Provide a wrapping function around the Cache Function that does not forward the Span argument to avoid this issue.");
+			startActiveSpanArgs[fnIdx] = (...cbArgs) => workUnitAsyncStorage.run(workUnitStore, originalFn, ...cbArgs);
+		}
+		return workUnitAsyncStorage.exit(() => originalStartActiveSpan(...startActiveSpanArgs));
 	};
+	extendedTracers.add(tracer);
+	return tracer;
 }
 //#endregion
 export { extendTracerProviderForCacheComponents };

package/dist/server/pages-api-route.d.ts

@@ -53,7 +53,7 @@ type PagesApiRouteModule = {
   runtime?: string;
   default?: PagesNodeApiRouteHandler | PagesEdgeApiRouteHandler;
 };
-type PagesApiRouteMatch = {
+export type PagesApiRouteMatch = {
   params: PagesRequestQuery;
   route: Pick<Route, "pattern"> & {
     module: PagesApiRouteModule;
@@ -69,6 +69,8 @@ type HandlePagesApiRouteOptions = {
    */
   ctx?: ExecutionContextLike;
   edgeRuntime?: EdgeApiExecutionRuntime;
+  /** Headers installed before user code, matching Next.js custom-route ordering. */
+  initialResponseHeaders?: Headers;
   match: PagesApiRouteMatch | null;
   reportRequestError?: (error: Error, routePattern: string) => void | Promise<void>;
   request: Request;
@@ -81,6 +83,5 @@ type HandlePagesApiRouteOptions = {
   };
   trustedRevalidateOrigin?: string;
 };
-declare function handlePagesApiRoute(options: HandlePagesApiRouteOptions): Promise<Response>;
-//#endregion
-export { PagesApiRouteMatch, handlePagesApiRoute };
+export declare function handlePagesApiRoute(options: HandlePagesApiRouteOptions): Promise<Response>;
+//#endregion

package/dist/server/pages-api-route.js

@@ -1,9 +1,10 @@
-import "./server-globals.js";
 import { getRequestExecutionContext, runWithExecutionContext } from "../shims/request-context.js";
+import "./server-globals.js";
 import { NextRequest } from "../shims/server.js";
 import { internalServerErrorResponse } from "./http-error-responses.js";
 import { cloneRequestWithUrl } from "./request-pipeline.js";
 import { mergeRouteParamsIntoQuery, parseQueryString, urlQueryToSearchParams } from "../utils/query.js";
+import { tracePagesApiHandler } from "./pages-execution-tracing.js";
 import { resolveBodyParserConfig } from "./pages-body-parser-config.js";
 import { PagesBodyParseError } from "./pages-media-type.js";
 import { createPagesReqRes, markVinextStreamedApiResponse, parsePagesApiBody } from "./pages-node-compat.js";
@@ -36,13 +37,26 @@ async function _handlePagesApiRoute(options) {
 	const { route, params } = options.match;
 	try {
 		if (isEdgeApiRouteModule(route.module)) {
+			const handler = route.module.default;
 			const nextRequest = new NextRequest(createEdgeApiRequest(options.request, options.url, params), options.nextConfig ? { nextConfig: {
 				basePath: options.nextConfig.basePath,
 				i18n: options.nextConfig.i18n ?? void 0,
 				trailingSlash: options.nextConfig.trailingSlash
 			} } : void 0);
-			const response = await route.module.default(nextRequest);
-			if (response instanceof Response) return finalizeEdgeApiResponse(response, options.edgeRuntime ?? "worker");
+			const response = await tracePagesApiHandler(route.pattern, () => handler(nextRequest));
+			if (response instanceof Response) {
+				const finalized = finalizeEdgeApiResponse(response, options.edgeRuntime ?? "worker");
+				if (!options.initialResponseHeaders || !options.initialResponseHeaders.keys().next().value) return finalized;
+				const headers = new Headers(options.initialResponseHeaders);
+				for (const [name, value] of finalized.headers) if (name.toLowerCase() !== "set-cookie") headers.set(name, value);
+				const finalizedCookies = finalized.headers.getSetCookie();
+				for (const cookie of finalizedCookies) headers.append("Set-Cookie", cookie);
+				return new Response(finalized.body, {
+					headers,
+					status: finalized.status,
+					statusText: finalized.statusText
+				});
+			}
 			throw new Error("Edge API route did not return a Response");
 		}
 		if (!isNodeApiRouteModule(route.module)) return new Response("API route does not export a default function", { status: 500 });
@@ -53,6 +67,7 @@ async function _handlePagesApiRoute(options) {
 		const { req, res, responsePromise } = createPagesReqRes({
 			allowedRevalidateHeaderKeys: options.nextConfig?.allowedRevalidateHeaderKeys,
 			body,
+			initialResponseHeaders: options.initialResponseHeaders,
 			query,
 			request: options.request,
 			trustedRevalidateOrigin: options.trustedRevalidateOrigin,
@@ -79,12 +94,10 @@ async function _handlePagesApiRoute(options) {
 			type: "response",
 			response
 		}));
-		const handlerCompletion = Promise.resolve().then(() => handler(req, res)).then(() => ({ type: "handler" }), destroyAfterHandlerError);
+		const handlerCompletion = Promise.resolve().then(() => tracePagesApiHandler(route.pattern, () => handler(req, res), { recordErrors: options.edgeRuntime !== "node" })).then(() => ({ type: "handler" }), destroyAfterHandlerError);
 		const firstSettled = await Promise.race([responseReady, handlerCompletion]);
 		if (firstSettled.type === "response") {
-			const handlerLifecycle = handlerCompletion.then(completeHandler, (error) => {
-				options.reportRequestError?.(error, route.pattern);
-			});
+			const handlerLifecycle = handlerCompletion.then(completeHandler, (error) => options.reportRequestError?.(error, route.pattern));
 			getRequestExecutionContext()?.waitUntil(handlerLifecycle);
 			return finalizeResponse(firstSettled.response);
 		}
@@ -95,7 +108,7 @@ async function _handlePagesApiRoute(options) {
 			status: error.statusCode,
 			statusText: error.message
 		});
-		options.reportRequestError?.(error instanceof Error ? error : new Error(String(error)), route.pattern);
+		await options.reportRequestError?.(error instanceof Error ? error : new Error(String(error)), route.pattern);
 		return internalServerErrorResponse();
 	}
 }

package/dist/server/pages-asset-tags.d.ts

@@ -13,14 +13,14 @@
  * Resolve the effective SSR manifest: prefer the caller-supplied object and
  * fall back to the registered client build metadata.
  */
-declare function resolveSsrManifest(manifest: Record<string, string[]> | null | undefined): Record<string, string[]> | null;
+export declare function resolveSsrManifest(manifest: Record<string, string[]> | null | undefined): Record<string, string[]> | null;
 /**
  * Look up the asset-file list for a module ID in the SSR manifest.
  *
  * The manifest keys may use relative paths while callers supply absolute
  * paths, so a suffix-match fallback is used when an exact-key lookup fails.
  */
-declare function getManifestFilesForModule(manifest: Record<string, string[]> | null | undefined, moduleId: string | null | undefined): string[] | null;
+export declare function getManifestFilesForModule(manifest: Record<string, string[]> | null | undefined, moduleId: string | null | undefined): string[] | null;
 /**
  * Find the first `.js` file in the manifest for `moduleId` and return the URL it
  * is actually SERVED from. Used to resolve the client-navigation / hydration URL
@@ -29,7 +29,7 @@ declare function getManifestFilesForModule(manifest: Record<string, string[]> |
  * asset URLs. SSR-manifest values are base-anchored; re-anchor under any
  * configured `assetPrefix` (default `""` keeps the legacy `"/" + file`).
  */
-declare function resolveClientModuleUrl(manifest: Record<string, string[]> | null | undefined, moduleId: string | null | undefined, basePath?: string, assetPrefix?: string, _deploymentId?: string): string | undefined;
+export declare function resolveClientModuleUrl(manifest: Record<string, string[]> | null | undefined, moduleId: string | null | undefined, basePath?: string, assetPrefix?: string, _deploymentId?: string): string | undefined;
 type CollectAssetTagsOptions = {
   /**
    * SSR manifest mapping module file paths to their associated asset list.
@@ -59,6 +59,7 @@ type CollectAssetTagsOptions = {
   assetPrefix?: string;
   deploymentId?: string;
   crossOrigin?: string;
+  initialStylesheetHrefs?: Set<string>;
 };
 /**
  * Build the HTML `<link>` and `<script>` tag string for the SSR response.
@@ -73,6 +74,5 @@ type CollectAssetTagsOptions = {
  *
  * Extracted from `entries/pages-server-entry.ts`.
  */
-declare function collectAssetTags(options: CollectAssetTagsOptions): string;
-//#endregion
-export { collectAssetTags, getManifestFilesForModule, resolveClientModuleUrl, resolveSsrManifest };
+export declare function collectAssetTags(options: CollectAssetTagsOptions): string;
+//#endregion

package/dist/server/pages-asset-tags.js

@@ -34,6 +34,30 @@ function getManifestFilesForModule(manifest, moduleId) {
 	for (const key in manifest) if (moduleId.endsWith("/" + key) || moduleId === key) return manifest[key];
 	return null;
 }
+function collectGraphOrderedCss(graph, moduleIds) {
+	const ordered = [];
+	const emitted = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	function findKey(moduleId) {
+		if (!moduleId) return void 0;
+		if (graph[moduleId]) return moduleId;
+		for (const key in graph) if (moduleId === key || moduleId.endsWith("/" + key)) return key;
+	}
+	function visit(key) {
+		if (!key || visited.has(key)) return;
+		visited.add(key);
+		const chunk = graph[key];
+		if (!chunk) return;
+		for (const importedKey of chunk.imports ?? []) visit(importedKey);
+		for (const file of chunk.css ?? []) {
+			if (emitted.has(file)) continue;
+			emitted.add(file);
+			ordered.push(file);
+		}
+	}
+	for (const moduleId of moduleIds) visit(findKey(moduleId));
+	return ordered;
+}
 /**
 * Find the first `.js` file in the manifest for `moduleId` and return the URL it
 * is actually SERVED from. Used to resolve the client-navigation / hydration URL
@@ -87,6 +111,14 @@ function collectAssetTags(options) {
 		tags.push("<link rel=\"modulepreload\"" + nonceAttr + " href=\"" + href(clientEntry) + "\"" + preloadCrossOriginAttr + " />");
 		tags.push("<script type=\"module\"" + deferAttr + nonceAttr + " src=\"" + href(clientEntry) + "\"" + scriptCrossOriginAttr + "><\/script>");
 	}
+	if (runtimeAssets.cssGraph) for (let file of collectGraphOrderedCss(runtimeAssets.cssGraph, options.moduleIds)) {
+		if (file.charAt(0) === "/") file = file.slice(1);
+		if (seen.has(file)) continue;
+		seen.add(file);
+		const stylesheetHref = href(file);
+		options.initialStylesheetHrefs?.add(stylesheetHref);
+		tags.push("<link rel=\"stylesheet\"" + nonceAttr + " href=\"" + stylesheetHref + "\" />");
+	}
 	if (m) {
 		const allFiles = [];
 		const moduleIds = options.moduleIds;
@@ -114,8 +146,11 @@ function collectAssetTags(options) {
 			if (tf.charAt(0) === "/") tf = tf.slice(1);
 			if (seen.has(tf)) continue;
 			seen.add(tf);
-			if (tf.endsWith(".css")) tags.push("<link rel=\"stylesheet\"" + nonceAttr + " href=\"" + href(tf) + "\" />");
-			else if (tf.endsWith(".js")) {
+			if (tf.endsWith(".css")) {
+				const stylesheetHref = href(tf);
+				options.initialStylesheetHrefs?.add(stylesheetHref);
+				tags.push("<link rel=\"stylesheet\"" + nonceAttr + " href=\"" + stylesheetHref + "\" />");
+			} else if (tf.endsWith(".js")) {
 				if (lazySet && lazySet.has(tf)) continue;
 				tags.push("<link rel=\"modulepreload\"" + nonceAttr + " href=\"" + href(tf) + "\"" + preloadCrossOriginAttr + " />");
 				tags.push("<script type=\"module\"" + deferAttr + nonceAttr + " src=\"" + href(tf) + "\"" + scriptCrossOriginAttr + "><\/script>");

package/dist/server/pages-body-parser-config.d.ts

@@ -23,7 +23,7 @@
 /**
  * Default Pages Router API body size limit, matching Next.js.
  */
-declare const DEFAULT_PAGES_API_BODY_SIZE_LIMIT: number;
+export declare const DEFAULT_PAGES_API_BODY_SIZE_LIMIT: number;
 /**
  * Resolved bodyParser configuration. When `enabled` is `false`, the body
  * MUST be passed through to the handler as a raw stream (or left unparsed
@@ -43,17 +43,16 @@ type ResolvedBodyParserConfig = {
  * Matches the format accepted by Next.js (the `bytes` package); we
  * implement it inline to avoid pulling a dependency for a tiny parser.
  */
-declare function parseSizeLimit(value: string | number | undefined): number | undefined;
+export declare function parseSizeLimit(value: string | number | undefined): number | undefined;
 /**
  * Read the resolved `bodyParser` config from a route module's `config`
  * export. Defaults to enabled with the 1 MB Next.js default.
  */
-declare function resolveBodyParserConfig(moduleConfig: {
+export declare function resolveBodyParserConfig(moduleConfig: {
   api?: {
     bodyParser?: boolean | {
       sizeLimit?: string | number;
     };
   };
 } | undefined, defaultSizeLimit?: number): ResolvedBodyParserConfig;
-//#endregion
-export { DEFAULT_PAGES_API_BODY_SIZE_LIMIT, parseSizeLimit, resolveBodyParserConfig };
+//#endregion

package/dist/server/pages-body-parser-config.js

@@ -23,13 +23,13 @@
 /**
 * Default Pages Router API body size limit, matching Next.js.
 */
-const DEFAULT_PAGES_API_BODY_SIZE_LIMIT = 1 * 1024 * 1024;
+const DEFAULT_PAGES_API_BODY_SIZE_LIMIT = 1048576;
 const SIZE_UNITS = {
 	b: 1,
 	kb: 1024,
-	mb: 1024 * 1024,
-	gb: 1024 * 1024 * 1024,
-	tb: 1024 * 1024 * 1024 * 1024
+	mb: 1048576,
+	gb: 1073741824,
+	tb: 1099511627776
 };
 /**
 * Parse a Next.js-style `sizeLimit` string (e.g. `"4mb"`, `"100kb"`, `"1gb"`)