vinext 1.0.0-beta.9 → 1.0.1

package/dist/server/navigation-trace.d.ts

@@ -1,7 +1,7 @@
 //#region src/server/navigation-trace.d.ts
-declare const NAVIGATION_TRACE_SCHEMA_VERSION = 0;
+export declare const NAVIGATION_TRACE_SCHEMA_VERSION = 0;
 type NavigationTraceSchemaVersion = 0;
-declare const NavigationTraceReasonCodes: {
+export declare const NavigationTraceReasonCodes: {
   cacheProofRejected: "NC_CACHE_REJECT";
   cacheReuseTokenRejected: "NC_CACHE_TOKEN_REJECT";
   commitCurrent: "NC_COMMIT";
@@ -36,26 +36,26 @@ declare const NavigationTraceReasonCodes: {
   streamedRedirectLoop: "NC_RSC_STREAMED_REDIRECT_LOOP";
   visitedResponseReuse: "NC_VISITED_REUSE";
 };
-declare const NavigationTraceTransactionCodes: {
+export declare const NavigationTraceTransactionCodes: {
   hardNavigate: "NT_HARD_NAVIGATE";
   noCommit: "NT_NO_COMMIT";
   visibleCommit: "NT_VISIBLE_COMMIT";
 };
-type NavigationTraceReasonCode = (typeof NavigationTraceReasonCodes)[keyof typeof NavigationTraceReasonCodes];
-type NavigationTraceTransactionCode = (typeof NavigationTraceTransactionCodes)[keyof typeof NavigationTraceTransactionCodes];
+export type NavigationTraceReasonCode = (typeof NavigationTraceReasonCodes)[keyof typeof NavigationTraceReasonCodes];
+export type NavigationTraceTransactionCode = (typeof NavigationTraceTransactionCodes)[keyof typeof NavigationTraceTransactionCodes];
 type NavigationTraceCode = NavigationTraceReasonCode | NavigationTraceTransactionCode;
 type NavigationTraceFieldName = "activeNavigationId" | "cacheProofCode" | "cacheProofMode" | "cacheProofReuseClass" | "cacheProofScope" | "cacheReuseTokenReason" | "currentRootLayoutTreePath" | "currentVisibleCommitVersion" | "nextRootLayoutTreePath" | "eventKind" | "fetchResultSource" | "freshFetchReason" | "operationLane" | "pendingOperationId" | "redirectDepth" | "redirectSignal" | "startedVisibleCommitVersion" | "startedNavigationId" | "targetHref" | "traverseDirection";
 type NavigationTraceFieldValue = string | number | boolean | null;
-type NavigationTraceFields = Readonly<Partial<Record<NavigationTraceFieldName, NavigationTraceFieldValue>>>;
+export type NavigationTraceFields = Readonly<Partial<Record<NavigationTraceFieldName, NavigationTraceFieldValue>>>;
 type NavigationTraceEntry = Readonly<{
   code: NavigationTraceCode;
   fields: NavigationTraceFields;
 }>;
-type NavigationTrace = Readonly<{
+export type NavigationTrace = Readonly<{
   schemaVersion: NavigationTraceSchemaVersion;
   entries: readonly NavigationTraceEntry[];
 }>;
-declare function createNavigationLifecycleTraceFields(options: {
+export declare function createNavigationLifecycleTraceFields(options: {
   activeNavigationId?: number;
   currentRootLayoutTreePath: string | null;
   currentVisibleCommitVersion: number;
@@ -63,7 +63,6 @@ declare function createNavigationLifecycleTraceFields(options: {
   startedNavigationId?: number;
   startedVisibleCommitVersion: number;
 }): NavigationTraceFields;
-declare function createNavigationTrace(code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
-declare function prependNavigationTraceEntry(trace: NavigationTrace, code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
-//#endregion
-export { NAVIGATION_TRACE_SCHEMA_VERSION, NavigationTrace, NavigationTraceFields, NavigationTraceReasonCode, NavigationTraceReasonCodes, NavigationTraceTransactionCode, NavigationTraceTransactionCodes, createNavigationLifecycleTraceFields, createNavigationTrace, prependNavigationTraceEntry };
+export declare function createNavigationTrace(code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
+export declare function prependNavigationTraceEntry(trace: NavigationTrace, code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
+//#endregion

package/dist/server/next-error-digest.d.ts

@@ -8,7 +8,7 @@ type NextHttpErrorDigest = {
  * Pulls a stringified `digest` off an unknown thrown value, or returns null
  * when the value is not a digest-bearing error.
  */
-declare function getNextErrorDigest(error: unknown): string | null;
+export declare function getNextErrorDigest(error: unknown): string | null;
 /**
  * Parses redirect digests from vinext's encoded three-part form and Next.js's
  * raw, semicolon-terminated form. Returns null when the digest is not a
@@ -17,12 +17,11 @@ declare function getNextErrorDigest(error: unknown): string | null;
  * 307 when omitted; an omitted `type` is left as null so the caller can apply
  * the correct context-sensitive default.
  */
-declare function parseNextRedirectDigest(digest: string): NextRedirectDigest | null;
+export declare function parseNextRedirectDigest(digest: string): NextRedirectDigest | null;
 /**
  * Parses a `NEXT_NOT_FOUND` or `NEXT_HTTP_ERROR_FALLBACK;<status>` digest.
  * Returns `{ status: 404 }` for `NEXT_NOT_FOUND` and the parsed status code
  * for the fallback form. Returns null otherwise.
  */
-declare function parseNextHttpErrorDigest(digest: string): NextHttpErrorDigest | null;
-//#endregion
-export { getNextErrorDigest, parseNextHttpErrorDigest, parseNextRedirectDigest };
+export declare function parseNextHttpErrorDigest(digest: string): NextHttpErrorDigest | null;
+//#endregion

package/dist/server/normalize-path.d.ts

@@ -1,5 +1,5 @@
 //#region src/server/normalize-path.d.ts
-declare function escapePathDelimiters(segment: string, escapeEncoded?: boolean): string;
+export declare function escapePathDelimiters(segment: string, escapeEncoded?: boolean): string;
 /**
  * Decode a URL pathname segment-by-segment, preserving encoded path delimiters.
  * Non-ASCII characters (e.g. %C3%A9 -> e) are decoded, but structural characters
@@ -11,8 +11,8 @@ declare function escapePathDelimiters(segment: string, escapeEncoded?: boolean):
  * Ported from Next.js: packages/next/src/server/lib/router-utils/decode-path-params.ts
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-utils/decode-path-params.ts
  */
-declare function decodePathParams(pathname: string): string;
-declare function isInterceptionMatchedUrlPath(value: string): boolean;
+export declare function decodePathParams(pathname: string): string;
+export declare function isInterceptionMatchedUrlPath(value: string): boolean;
 /**
  * Path normalization utility for request handling.
  *
@@ -33,6 +33,5 @@ declare function isInterceptionMatchedUrlPath(value: string): boolean;
  *  - Decode percent-encoded characters (callers should decode before calling this)
  *  - Lowercase the path (route matching is case-sensitive)
  */
-declare function normalizePath(pathname: string): string;
-//#endregion
-export { decodePathParams, escapePathDelimiters, isInterceptionMatchedUrlPath, normalizePath };
+export declare function normalizePath(pathname: string): string;
+//#endregion

package/dist/server/open-redirect.d.ts

@@ -7,6 +7,5 @@
  * after decoding backslashes and encoded delimiters, would cause a browser
  * to resolve a `Location` containing the pathname as protocol-relative.
  */
-declare function isOpenRedirectShaped(rawPathname: string): boolean;
-//#endregion
-export { isOpenRedirectShaped };
+export declare function isOpenRedirectShaped(rawPathname: string): boolean;
+//#endregion

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

@@ -3,7 +3,10 @@ import "./server-globals.js";
 import { NextRequest } from "../shims/server.js";
 import { internalServerErrorResponse } from "./http-error-responses.js";
 import { cloneRequestWithUrl } from "./request-pipeline.js";
+import { markRouteCacheabilityExplicitResponsePolicy } from "../shims/cacheability-classification.js";
+import { hasCdnResponsePolicy } from "./cache-control.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";
@@ -28,21 +31,38 @@ function isNodeApiRouteModule(module) {
 	return typeof module.default === "function" && !isEdgeApiRuntime(resolveModuleRuntime(module));
 }
 async function handlePagesApiRoute(options) {
-	if (options.ctx) return runWithExecutionContext(options.ctx, () => _handlePagesApiRoute(options));
-	return _handlePagesApiRoute(options);
+	const run = async () => {
+		const response = await _handlePagesApiRoute(options);
+		if (hasCdnResponsePolicy(response.headers)) markRouteCacheabilityExplicitResponsePolicy();
+		return response;
+	};
+	return options.ctx ? runWithExecutionContext(options.ctx, run) : run();
 }
 async function _handlePagesApiRoute(options) {
 	if (!options.match) return new Response("404 - API route not found", { status: 404 });
 	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 +73,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 +100,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 +114,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();
 	}
 }