@qzsy/vinext 0.1.12 → 0.1.81

package/dist/server/app-server-action-execution.js

@@ -5,14 +5,16 @@ import { isExternalUrl } from "../config/config-matchers.js";
 import { internalServerErrorResponse, payloadTooLargeResponse } from "./http-error-responses.js";
 import { validateCsrfOrigin, validateServerActionPayload } from "./request-pipeline.js";
 import { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI } from "./app-rsc-render-mode.js";
-import { headersContextFromRequest, setHeadersContext } from "../shims/headers.js";
+import { headersContextFromRequest, isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
 import { getAndClearActionRevalidationKind } from "../shims/cache-request-state.js";
 import { setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
+import { applyServerActionLogHeader, createServerActionLogInfo, isDevServerActionLoggingEnabled } from "./server-action-logger.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { getNextErrorDigest, parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
+import { createRootParamsUsageController, pickRootParams, runWithRootParamsScope, runWithRootParamsUsage } from "../shims/root-params.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage, isServerActionNotFoundError } from "./server-action-not-found.js";
 import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import "./app-page-stream.js";
@@ -20,7 +22,29 @@ import { buildAppPageTags } from "./implicit-tags.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
 import { resolveAppPageActionRerenderTarget } from "./app-page-request.js";
 import { getSetCookieName } from "./cookie-utils.js";
+import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
 //#region src/server/app-server-action-execution.ts
+function prepareActionPageRerenderContext(options) {
+	if (options.dynamicConfig === "force-static" || options.dynamicConfig === "error") setHeadersContext(createStaticGenerationHeadersContext({
+		draftModeEnabled: isDraftModeRequest(createActionRerenderRequest({
+			draftModeCookie: options.draftModeCookie,
+			request: options.request
+		}), options.draftModeSecret),
+		draftModeSecret: options.draftModeSecret,
+		dynamicConfig: options.dynamicConfig,
+		routeKind: "page",
+		routePattern: options.routePattern
+	}));
+	return options.dynamicConfig === "force-static" ? new URLSearchParams() : options.searchParams;
+}
+function createActionRerenderRequest(options) {
+	if (!options.draftModeCookie) return options.request;
+	const headers = new Headers(options.request.headers);
+	const cookieHeader = applySetCookieMutationsToRequestCookieHeader(headers.get("cookie"), [options.draftModeCookie]);
+	if (cookieHeader === null) headers.delete("cookie");
+	else headers.set("cookie", cookieHeader);
+	return new Request(options.request.url, { headers });
+}
 /**
 * Matches Next.js' server action argument cap to prevent stack overflow in
 * Function.prototype.apply when decoding hostile action payloads.
@@ -351,11 +375,14 @@ async function handleProgressiveServerActionRequest(options) {
 		let actionRedirect = null;
 		let actionError = void 0;
 		let actionFailed = false;
+		let actionThrew = false;
 		let actionResult;
+		const rootParamsUsage = createRootParamsUsageController();
 		const previousHeadersPhase = options.setHeadersAccessPhase("action");
 		try {
-			actionResult = await action();
+			actionResult = await runWithRootParamsUsage({ kind: "server-action" }, action, rootParamsUsage);
 		} catch (error) {
+			actionThrew = true;
 			actionRedirect = getActionRedirect(error);
 			if (!actionRedirect) {
 				actionError = error;
@@ -375,8 +402,10 @@ async function handleProgressiveServerActionRequest(options) {
 			}
 		} finally {
 			options.setHeadersAccessPhase(previousHeadersPhase);
+			if (actionThrew) rootParamsUsage.transitionToRender();
 		}
 		if (!actionRedirect) {
+			if (!actionThrew) rootParamsUsage.transitionToRender();
 			const actionPendingCookies = dedupePendingCookies(options.getAndClearPendingCookies());
 			const actionDraftCookie = options.getDraftModeCookieHeader();
 			const revalidationKind = resolveActionRevalidationKind(actionPendingCookies.length > 0 || Boolean(actionDraftCookie));
@@ -544,16 +573,22 @@ async function handleServerActionRscRequest(options) {
 		let returnValue;
 		let actionRedirect = null;
 		let actionStatus = 200;
+		let actionThrew = false;
 		const actionWasForwarded = Boolean(options.request.headers.get(ACTION_FORWARDED_HEADER));
+		const rootParamsUsage = createRootParamsUsageController();
+		const shouldLogAction = isDevServerActionLoggingEnabled();
+		const actionLogStart = shouldLogAction ? performance.now() : 0;
+		let actionLogInfo = null;
 		const previousHeadersPhase = options.setHeadersAccessPhase("action");
 		try {
 			try {
 				validateServerActionArgs(args);
 				returnValue = {
 					ok: true,
-					data: await action.apply(null, args)
+					data: await runWithRootParamsUsage({ kind: "server-action" }, () => action.apply(null, args), rootParamsUsage)
 				};
 			} catch (error) {
+				actionThrew = true;
 				actionRedirect = getActionRedirect(error);
 				if (actionRedirect) returnValue = {
 					ok: true,
@@ -568,6 +603,7 @@ async function handleServerActionRscRequest(options) {
 							data: error
 						};
 					} else {
+						actionStatus = 500;
 						console.error("[vinext] Server action error:", error);
 						returnValue = {
 							ok: false,
@@ -577,7 +613,13 @@ async function handleServerActionRscRequest(options) {
 				}
 			}
 		} finally {
+			if (shouldLogAction) actionLogInfo = createServerActionLogInfo({
+				actionId: options.actionId,
+				args,
+				durationMs: Math.round(performance.now() - actionLogStart)
+			});
 			options.setHeadersAccessPhase(previousHeadersPhase);
+			if (actionThrew && !actionWasForwarded) rootParamsUsage.transitionToRender();
 		}
 		if (actionRedirect) {
 			const actionPendingCookies = dedupePendingCookies(options.getAndClearPendingCookies());
@@ -597,6 +639,7 @@ async function handleServerActionRscRequest(options) {
 			for (const cookie of actionPendingCookies) redirectHeaders.append("Set-Cookie", cookie);
 			if (actionDraftCookie) redirectHeaders.append("Set-Cookie", actionDraftCookie);
 			setActionRevalidatedHeader(redirectHeaders, actionRevalidationKind);
+			applyServerActionLogHeader(redirectHeaders, actionLogInfo);
 			const redirectTarget = resolveInternalActionRedirectTarget(actionRedirectUrl, options.request.url, options.basePath ?? "");
 			if (!redirectTarget) {
 				options.clearRequestContext();
@@ -622,35 +665,48 @@ async function handleServerActionRscRequest(options) {
 				request: options.request,
 				url: redirectTarget
 			});
-			setHeadersContext(headersContextFromRequest(redirectRenderRequest));
+			setHeadersContext(headersContextFromRequest(redirectRenderRequest, { draftModeSecret: options.draftModeSecret }));
+			const redirectDynamicConfig = options.resolveRouteDynamicConfig?.(targetMatch.route);
+			const redirectSearchParams = prepareActionPageRerenderContext({
+				draftModeCookie: actionDraftCookie,
+				draftModeSecret: options.draftModeSecret,
+				dynamicConfig: redirectDynamicConfig,
+				request: redirectRenderRequest,
+				routePattern: targetMatch.route.pattern,
+				searchParams: redirectTarget.searchParams
+			});
 			const redirectNavigationParams = resolveAppPageNavigationParams(targetMatch.route, targetMatch.params, targetPathname, null);
 			options.setNavigationContext({
 				pathname: targetPathname,
-				searchParams: redirectTarget.searchParams,
+				searchParams: redirectSearchParams,
 				params: redirectNavigationParams
 			});
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(targetMatch.route) ?? null);
-			setCurrentForceDynamicFetchDefault(options.resolveRouteDynamicConfig?.(targetMatch.route) === "force-dynamic");
+			setCurrentForceDynamicFetchDefault(redirectDynamicConfig === "force-dynamic");
 			setCurrentFetchSoftTags(buildServerActionPageTags(targetMatch.route, targetPathname));
-			const element = options.buildPageElement({
-				cleanPathname: targetPathname,
-				interceptOpts: void 0,
-				isRscRequest: true,
-				mountedSlotsHeader: null,
-				params: targetMatch.params,
-				request: redirectRenderRequest,
-				route: targetMatch.route,
-				searchParams: redirectTarget.searchParams,
-				renderMode: APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI
-			});
-			const onRenderError = options.createRscOnErrorHandler(redirectRenderRequest, targetPathname, targetMatch.route.pattern);
-			return createServerActionRscResponse(await options.renderToReadableStream({
-				root: element,
-				returnValue
-			}, {
-				temporaryReferences,
-				onError: onRenderError
-			}), {
+			return createServerActionRscResponse(await runWithRootParamsScope(pickRootParams(targetMatch.params, targetMatch.route.rootParamNames), () => runWithRootParamsUsage({ kind: "route" }, async () => {
+				const element = options.buildPageElement({
+					cleanPathname: targetPathname,
+					interceptOpts: void 0,
+					isRscRequest: true,
+					mountedSlotsHeader: null,
+					params: targetMatch.params,
+					request: redirectRenderRequest,
+					route: targetMatch.route,
+					searchParams: redirectSearchParams,
+					renderMode: APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI,
+					observeMetadataSearchParamsAccess: redirectDynamicConfig !== "force-static",
+					observePageSearchParamsAccess: redirectDynamicConfig !== "force-static"
+				});
+				const onRenderError = options.createRscOnErrorHandler(redirectRenderRequest, targetPathname, targetMatch.route.pattern);
+				return options.renderToReadableStream({
+					root: element,
+					returnValue
+				}, {
+					temporaryReferences,
+					onError: onRenderError
+				});
+			})), {
 				status: shouldUseForwardedActionRedirectStatus({
 					actionWasForwarded,
 					currentPathname: options.cleanPathname,
@@ -665,7 +721,8 @@ async function handleServerActionRscRequest(options) {
 		const actionPendingCookies = dedupePendingCookies(options.getAndClearPendingCookies());
 		const actionDraftCookie = options.getDraftModeCookieHeader();
 		const actionRevalidationKind = resolveActionRevalidationKind(actionPendingCookies.length > 0 || Boolean(actionDraftCookie));
-		if (actionWasForwarded || actionStatus === 200 && actionRevalidationKind === ACTION_DID_NOT_REVALIDATE) {
+		const isHttpFallback = actionStatus === 401 || actionStatus === 403 || actionStatus === 404;
+		if (!isHttpFallback && (actionWasForwarded || actionRevalidationKind === ACTION_DID_NOT_REVALIDATE)) {
 			const onRenderError = options.createRscOnErrorHandler(options.request, options.cleanPathname, options.cleanPathname);
 			const rscStream = await options.renderToReadableStream({ returnValue }, {
 				temporaryReferences,
@@ -681,11 +738,13 @@ async function handleServerActionRscRequest(options) {
 			for (const cookie of actionPendingCookies) actionHeaders.append("Set-Cookie", cookie);
 			if (actionDraftCookie) actionHeaders.append("Set-Cookie", actionDraftCookie);
 			setActionRevalidatedHeader(actionHeaders, actionRevalidationKind);
+			applyServerActionLogHeader(actionHeaders, actionLogInfo);
 			return createServerActionRscResponse(rscStream, {
 				status: options.middlewareStatus ?? actionStatus,
 				headers: actionHeaders
 			}, options.clearRequestContext);
 		}
+		if (!actionThrew) rootParamsUsage.transitionToRender();
 		const match = options.matchRoute(options.cleanPathname);
 		let element;
 		let errorPattern = match ? match.route.pattern : options.cleanPathname;
@@ -702,16 +761,25 @@ async function handleServerActionRscRequest(options) {
 				toInterceptOpts: options.toInterceptOpts
 			});
 			const resolvedActionNavigationParams = resolveAppPageNavigationParams(actionRerenderTarget.route, actionRerenderTarget.navigationParams, options.cleanPathname, actionRerenderTarget.interceptOpts);
+			await options.ensureRouteLoaded?.(actionRerenderTarget.route);
+			const actionRerenderDynamicConfig = options.resolveRouteDynamicConfig?.(actionRerenderTarget.route);
+			const actionRerenderSearchParams = prepareActionPageRerenderContext({
+				draftModeCookie: actionDraftCookie,
+				draftModeSecret: options.draftModeSecret,
+				dynamicConfig: actionRerenderDynamicConfig,
+				request: options.request,
+				routePattern: actionRerenderTarget.route.pattern,
+				searchParams: options.searchParams
+			});
 			options.setNavigationContext({
 				pathname: options.cleanPathname,
-				searchParams: options.searchParams,
+				searchParams: actionRerenderSearchParams,
 				params: resolvedActionNavigationParams
 			});
-			await options.ensureRouteLoaded?.(actionRerenderTarget.route);
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(actionRerenderTarget.route) ?? null);
-			setCurrentForceDynamicFetchDefault(options.resolveRouteDynamicConfig?.(actionRerenderTarget.route) === "force-dynamic");
+			setCurrentForceDynamicFetchDefault(actionRerenderDynamicConfig === "force-dynamic");
 			setCurrentFetchSoftTags(buildServerActionPageTags(actionRerenderTarget.route, options.cleanPathname));
-			element = options.buildPageElement({
+			const buildActionRerenderElement = () => options.buildPageElement({
 				cleanPathname: options.cleanPathname,
 				interceptOpts: actionRerenderTarget.interceptOpts,
 				isRscRequest: options.isRscRequest,
@@ -719,22 +787,26 @@ async function handleServerActionRscRequest(options) {
 				params: actionRerenderTarget.params,
 				request: options.request,
 				route: actionRerenderTarget.route,
-				searchParams: options.searchParams,
-				renderMode: APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI
+				searchParams: actionRerenderSearchParams,
+				renderMode: APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI,
+				observeMetadataSearchParamsAccess: actionRerenderDynamicConfig !== "force-static",
+				observePageSearchParamsAccess: actionRerenderDynamicConfig !== "force-static"
 			});
+			element = actionWasForwarded && isHttpFallback ? await runWithRootParamsUsage({ kind: "route" }, async () => buildActionRerenderElement()) : buildActionRerenderElement();
 			errorPattern = actionRerenderTarget.route.pattern;
 		} else {
 			const actionRouteId = options.createPayloadRouteId(options.cleanPathname, null);
 			element = options.createNotFoundElement(actionRouteId);
 		}
 		const onRenderError = options.createRscOnErrorHandler(options.request, options.cleanPathname, errorPattern);
-		const rscStream = await options.renderToReadableStream({
+		const renderActionRerender = () => options.renderToReadableStream({
 			root: element,
 			returnValue
 		}, {
 			temporaryReferences,
 			onError: onRenderError
 		});
+		const rscStream = await (actionWasForwarded && isHttpFallback ? runWithRootParamsUsage({ kind: "route" }, renderActionRerender) : renderActionRerender());
 		const actionHeaders = new Headers({
 			"Content-Type": VINEXT_RSC_CONTENT_TYPE,
 			Vary: VINEXT_RSC_VARY_HEADER
@@ -743,6 +815,7 @@ async function handleServerActionRscRequest(options) {
 		mergeMiddlewareResponseHeaders(actionHeaders, options.middlewareHeaders);
 		applyRscCompatibilityIdHeader(actionHeaders);
 		setActionRevalidatedHeader(actionHeaders, actionRevalidationKind);
+		applyServerActionLogHeader(actionHeaders, actionLogInfo);
 		const actionResponse = createServerActionRscResponse(rscStream, {
 			status: options.middlewareStatus ?? actionStatus,
 			headers: actionHeaders

package/dist/server/app-ssr-entry.js

@@ -16,6 +16,7 @@ import DefaultGlobalError from "../shims/default-global-error.js";
 import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
 import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
 import { createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform } from "./app-ssr-stream.js";
+import { setPagesClientAssets } from "./pages-client-assets.js";
 import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
 import { runWithRootParamsScope } from "../shims/root-params.js";
 import { createInitialBfcacheMaps } from "./app-bfcache-identity.js";
@@ -27,9 +28,12 @@ import { createInitialDevServerErrorScript } from "./dev-initial-server-error.js
 import { ssrAppRouterInstance } from "./app-ssr-router-instance.js";
 import { Fragment, createElement, use } from "react";
 import { renderToReadableStream, renderToStaticMarkup } from "react-dom/server.edge";
+import { preinitModule } from "react-dom";
 import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
 import clientReferences from "virtual:vite-rsc/client-references";
+import pagesClientAssets from "virtual:vinext-pages-client-assets";
 //#region src/server/app-ssr-entry.ts
+setPagesClientAssets(pagesClientAssets);
 /**
 * Default cap for the preload `Link` header, matching Next.js's
 * `defaultConfig.reactMaxHeadersLength`. Used when no config value threads
@@ -52,7 +56,10 @@ async function loadStaticPrerender() {
 		const [{ createRequire }, path] = await Promise.all([import("node:module"), import("node:path")]);
 		const reactDomPackageJson = createRequire(import.meta.url).resolve("react-dom/package.json");
 		const reactDomDir = path.dirname(reactDomPackageJson);
-		const devRenderer = await import(path.join(reactDomDir, "cjs/react-dom-server.edge.development.js"));
+		const devRenderer = await import(
+			/* @vite-ignore */
+			path.join(reactDomDir, "cjs/react-dom-server.edge.development.js")
+);
 		if (isStaticPrerenderModule(devRenderer)) return devRenderer.prerender;
 		const devRendererDefault = typeof devRenderer === "object" && devRenderer !== null && "default" in devRenderer && devRenderer.default;
 		if (isStaticPrerenderModule(devRendererDefault)) return devRendererDefault.prerender;
@@ -182,6 +189,10 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 				}
 				let flightRoot = null;
 				function VinextFlightRoot() {
+					for (const moduleUrl of pagesClientAssets.appBootstrapPreinitModules ?? []) preinitModule(moduleUrl, {
+						as: "script",
+						nonce: options?.scriptNonce
+					});
 					if (!flightRoot) flightRoot = createFromReadableStream(ssrStream);
 					const wireElements = use(flightRoot);
 					const elements = AppElementsWire.decode(wireElements);

package/dist/server/app-static-generation.d.ts

@@ -3,6 +3,7 @@ import { HeadersContext } from "../shims/headers.js";
 //#region src/server/app-static-generation.d.ts
 type AppStaticGenerationRouteKind = "page" | "route";
 type CreateStaticGenerationHeadersContextOptions = {
+  draftModeEnabled?: boolean;
   draftModeSecret?: string;
   dynamicConfig?: string;
   routeKind: AppStaticGenerationRouteKind;

package/dist/server/app-static-generation.js

@@ -9,6 +9,7 @@ function createStaticGenerationHeadersContext(options) {
 	const context = {
 		headers: new Headers(),
 		cookies: /* @__PURE__ */ new Map(),
+		draftModeEnabled: options.draftModeEnabled,
 		draftModeSecret: options.draftModeSecret
 	};
 	if (options.dynamicConfig === "force-static") context.forceStatic = true;

package/dist/server/client-trace-metadata.js

@@ -24,7 +24,32 @@ const carrierSetter = { set(carrier, key, value) {
 		value
 	});
 } };
+const OPEN_TELEMETRY_API_SYMBOL = Symbol.for("opentelemetry.js.api.1");
+const OPEN_TELEMETRY_SPAN_SYMBOL = Symbol.for("OpenTelemetry Context Key SPAN");
+function getRegisteredOpenTelemetryTraceData() {
+	let metadataSpan = null;
+	try {
+		const registry = globalThis[OPEN_TELEMETRY_API_SYMBOL];
+		if (!registry?.context || !registry.propagation) return null;
+		const contextApi = registry.context;
+		const propagation = registry.propagation;
+		const activeContext = contextApi.active();
+		metadataSpan = activeContext.getValue(OPEN_TELEMETRY_SPAN_SYMBOL) !== void 0 ? null : registry.trace?.getTracer("vinext").startSpan("vinext.clientTraceMetadata", void 0, activeContext) ?? null;
+		const context = metadataSpan ? activeContext.setValue(OPEN_TELEMETRY_SPAN_SYMBOL, metadataSpan) : activeContext;
+		const entries = [];
+		contextApi.with(context, () => {
+			propagation.inject(context, entries, carrierSetter);
+		});
+		return entries;
+	} catch {
+		return [];
+	} finally {
+		metadataSpan?.end();
+	}
+}
 function getOpenTelemetryTraceData() {
+	const registeredEntries = getRegisteredOpenTelemetryTraceData();
+	if (registeredEntries) return registeredEntries;
 	let api;
 	try {
 		const req = globalThis.require;
@@ -75,6 +100,7 @@ function renderClientTraceMetadataTags(entries) {
 */
 function getClientTraceMetadataHTML(allowList) {
 	if (!allowList || allowList.length === 0) return "";
+	if (typeof process !== "undefined" && process.env.VINEXT_PRERENDER === "1") return "";
 	return renderClientTraceMetadataTags(filterClientTraceMetadata(getOpenTelemetryTraceData(), allowList));
 }
 //#endregion

package/dist/server/default-global-not-found-module.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+
+//#region src/server/default-global-not-found-module.d.ts
+declare function DefaultGlobalNotFound(): React.ReactElement;
+/**
+ * Module-shaped wrapper around Next.js's built-in global not-found document.
+ * Unlike the regular default not-found boundary, this component owns the
+ * document shell because global not-found responses skip the root layout.
+ */
+declare const DEFAULT_GLOBAL_NOT_FOUND_MODULE: {
+  readonly default: typeof DefaultGlobalNotFound;
+};
+//#endregion
+export { DEFAULT_GLOBAL_NOT_FOUND_MODULE };

package/dist/server/default-global-not-found-module.js

@@ -0,0 +1,14 @@
+import DefaultNotFound from "../shims/default-not-found.js";
+import React from "react";
+//#region src/server/default-global-not-found-module.ts
+function DefaultGlobalNotFound() {
+	return React.createElement("html", null, React.createElement("body", null, React.createElement(DefaultNotFound)));
+}
+/**
+* Module-shaped wrapper around Next.js's built-in global not-found document.
+* Unlike the regular default not-found boundary, this component owns the
+* document shell because global not-found responses skip the root layout.
+*/
+const DEFAULT_GLOBAL_NOT_FOUND_MODULE = { default: DefaultGlobalNotFound };
+//#endregion
+export { DEFAULT_GLOBAL_NOT_FOUND_MODULE };

package/dist/server/dev-response-headers.d.ts

@@ -0,0 +1,19 @@
+import { RequestLogOptions } from "./request-log.js";
+import { ServerResponse } from "node:http";
+
+//#region src/server/dev-response-headers.d.ts
+type DevResponseMetrics = {
+  compileMs?: number;
+  renderMs?: number;
+  actionLogRaw?: string;
+};
+declare function parseVinextTimingHeader(raw: unknown, reqStart: number): Pick<DevResponseMetrics, "compileMs" | "renderMs">;
+/** Intercept dev-only headers on a Node response and capture their payloads. */
+declare function interceptDevResponseHeaders(res: ServerResponse, reqStart: number, metrics: DevResponseMetrics): void;
+declare function flushDevRequestLogs(metrics: DevResponseMetrics, options: RequestLogOptions): void;
+/** Install App Router request + server action logging on the Vite dev server. */
+declare function installAppRouterDevRequestLogging(middlewares: {
+  use: (handler: (req: import("node:http").IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => void) => void;
+}): void;
+//#endregion
+export { DevResponseMetrics, flushDevRequestLogs, installAppRouterDevRequestLogging, interceptDevResponseHeaders, parseVinextTimingHeader };

package/dist/server/dev-response-headers.js

@@ -0,0 +1,78 @@
+import "./headers.js";
+import { parseServerActionLogHeader } from "./server-action-logger.js";
+import { logRequest, logServerAction, now } from "./request-log.js";
+//#region src/server/dev-response-headers.ts
+function parseVinextTimingHeader(raw, reqStart) {
+	const [handlerStart, inHandlerCompileMs, renderMs] = String(raw).split(",").map((v) => Number(v));
+	const metrics = {};
+	if (!Number.isNaN(handlerStart) && !Number.isNaN(inHandlerCompileMs) && inHandlerCompileMs !== -1) metrics.compileMs = Math.max(0, Math.round(handlerStart - reqStart)) + inHandlerCompileMs;
+	if (!Number.isNaN(renderMs) && renderMs !== -1) metrics.renderMs = renderMs;
+	return metrics;
+}
+function consumeDevInternalHeader(name, value, reqStart, metrics) {
+	const lowerName = name.toLowerCase();
+	if (lowerName === "x-vinext-timing") {
+		Object.assign(metrics, parseVinextTimingHeader(value, reqStart));
+		return true;
+	}
+	if (lowerName === "x-vinext-action-log") {
+		metrics.actionLogRaw = String(value);
+		return true;
+	}
+	return false;
+}
+function stripDevInternalHeadersFromObject(headers, reqStart, metrics) {
+	for (const key of Object.keys(headers)) if (consumeDevInternalHeader(key, headers[key], reqStart, metrics)) delete headers[key];
+}
+/** Intercept dev-only headers on a Node response and capture their payloads. */
+function interceptDevResponseHeaders(res, reqStart, metrics) {
+	const origSetHeader = res.setHeader.bind(res);
+	res.setHeader = function(name, value) {
+		if (consumeDevInternalHeader(String(name), value, reqStart, metrics)) return res;
+		return origSetHeader(name, value);
+	};
+	const origWriteHead = res.writeHead.bind(res);
+	res.writeHead = function(statusCode, ...args) {
+		let headers;
+		const [reasonOrHeaders, maybeHeaders] = args;
+		if (typeof reasonOrHeaders === "string") headers = maybeHeaders;
+		else headers = reasonOrHeaders;
+		if (headers && typeof headers === "object" && !Array.isArray(headers)) stripDevInternalHeadersFromObject(headers, reqStart, metrics);
+		return origWriteHead(statusCode, ...args);
+	};
+}
+function flushDevRequestLogs(metrics, options) {
+	logRequest(options);
+	const actionLog = metrics.actionLogRaw ? parseServerActionLogHeader(metrics.actionLogRaw) : null;
+	if (actionLog) logServerAction(actionLog);
+}
+function shouldSkipDevRequestLogUrl(url) {
+	const [pathname] = url.split("?");
+	return url.startsWith("/@") || url.startsWith("/__vite") || url.startsWith("/node_modules") || url.includes(".") && !pathname.endsWith(".html") && !pathname.endsWith(".rsc");
+}
+/** Install App Router request + server action logging on the Vite dev server. */
+function installAppRouterDevRequestLogging(middlewares) {
+	middlewares.use((req, res, next) => {
+		const url = req.url ?? "/";
+		if (shouldSkipDevRequestLogUrl(url)) return next();
+		const reqStart = now();
+		const metrics = {};
+		interceptDevResponseHeaders(res, reqStart, metrics);
+		res.on("finish", () => {
+			const logUrl = url.replace(/\.rsc(\?|$)/, "$1");
+			const totalMs = now() - reqStart;
+			const resolvedRenderMs = metrics.renderMs !== void 0 ? metrics.renderMs : metrics.compileMs !== void 0 ? Math.max(0, Math.round(totalMs - metrics.compileMs)) : void 0;
+			flushDevRequestLogs(metrics, {
+				method: req.method ?? "GET",
+				url: logUrl,
+				status: res.statusCode,
+				totalMs,
+				compileMs: metrics.compileMs,
+				renderMs: resolvedRenderMs
+			});
+		});
+		next();
+	});
+}
+//#endregion
+export { flushDevRequestLogs, installAppRouterDevRequestLogging, interceptDevResponseHeaders, parseVinextTimingHeader };

package/dist/server/dev-server.js

@@ -3,7 +3,6 @@ import { createValidFileMatcher, findFileWithExtensions } from "../routing/file-
 import { patternToNextFormat } from "../routing/route-validation.js";
 import { matchRoute } from "../routing/pages-router.js";
 import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
-import { normalizeStaticPathname } from "../routing/route-pattern.js";
 import { importModule, reportRequestError } from "./instrumentation.js";
 import { buildCacheStateHeaders } from "./cache-headers.js";
 import { isUnknownRecord } from "../utils/record.js";
@@ -26,12 +25,13 @@ import { detectLocaleFromAcceptLanguage, extractLocaleFromUrl as extractLocaleFr
 import { buildDefaultPagesNotFoundResponse } from "./pages-default-404.js";
 import { buildPagesReadinessNextData } from "./pages-readiness.js";
 import { resolvePagesPageMethodResponse } from "./pages-page-method.js";
-import { createPagesDevModuleUrl } from "./pages-dev-module-url.js";
-import { isSerializableProps } from "./pages-serializable-props.js";
 import { loadUserDocumentInitialProps, runDocumentRenderPage } from "./pages-document-initial-props.js";
 import { callDocumentGetInitialProps } from "./document-initial-head.js";
 import { hasPagesGetInitialProps, loadDevAppInitialProps, loadPagesGetInitialProps } from "./pages-get-initial-props.js";
+import { isSerializableProps } from "./pages-serializable-props.js";
 import { isBotUserAgent } from "../utils/html-limited-bots.js";
+import { getPagesRouteParams, matchesPagesStaticPath } from "./pages-page-data.js";
+import { createPagesDevModuleUrl } from "./pages-dev-module-url.js";
 import path from "node:path";
 import React from "react";
 import { renderToReadableStream } from "react-dom/server.edge";
@@ -248,8 +248,9 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 			if (isDataReq) {
 				const deploymentId = process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID;
 				const notFoundHeaders = { "Content-Type": "application/json" };
+				if (hasMiddleware) notFoundHeaders["x-nextjs-matched-path"] = `${locale ? `/${locale}` : ""}${localeStrippedUrl}`;
 				if (deploymentId) notFoundHeaders[NEXTJS_DEPLOYMENT_ID_HEADER] = deploymentId;
-				res.writeHead(404, notFoundHeaders);
+				res.writeHead(hasMiddleware ? 200 : 404, notFoundHeaders);
 				res.end("{}");
 				return;
 			}
@@ -340,17 +341,8 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 					});
 					const fallback = pathsResult?.fallback ?? false;
 					const paths = pathsResult?.paths ?? [];
-					const currentPathname = normalizeStaticPathname(url);
-					const isValidPath = paths.some((p) => {
-						if (typeof p === "string") return normalizeStaticPathname(p) === currentPathname;
-						const entryParams = p.params;
-						if (entryParams === void 0 || entryParams === null) return false;
-						return Object.entries(entryParams).every(([key, val]) => {
-							const actual = params[key];
-							if (Array.isArray(val)) return Array.isArray(actual) && val.join("/") === actual.join("/");
-							return String(val) === String(actual);
-						});
-					});
+					const routeParams = getPagesRouteParams(patternToNextFormat(route.pattern));
+					const isValidPath = paths.some((pathEntry) => matchesPagesStaticPath(pathEntry, params, routeParams, url));
 					if (fallback === false && !isValidPath) {
 						if (isDataReq) {
 							const deploymentId = process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID;
@@ -762,6 +754,7 @@ function createSSRHandler(server, runner, routes, pagesDir, i18nConfig, fileMatc
 						setRevalidateDuration(cacheKey, revalidateSeconds);
 					}
 					const dataHeaders = { "Content-Type": "application/json" };
+					if ((statusCode ?? 200) === 200) dataHeaders["x-nextjs-matched-path"] = `${locale ? `/${locale}` : ""}${patternToNextFormat(route.pattern)}`;
 					if (gsspExtraHeaders) for (const [k, v] of Object.entries(gsspExtraHeaders)) dataHeaders[k] = v;
 					const dataRoutePattern = patternToNextFormat(route.pattern);
 					if (dataRoutePattern !== "/_error" && dataRoutePattern !== "/500") {

package/dist/server/dev-stack-sourcemap.d.ts

@@ -1,4 +1,4 @@
-import { VINEXT_ORIGINAL_STACK_TRACE_ENDPOINT } from "./dev-stack-sourcemap-endpoint.js";
+import { VINEXT_ORIGINAL_STACK_TRACE_ENDPOINT } from "../utils/dev-stack-sourcemap-endpoint.js";
 import { ViteDevServer } from "vite";
 
 //#region src/server/dev-stack-sourcemap.d.ts

package/dist/server/dev-stack-sourcemap.js

@@ -1,4 +1,4 @@
-import { VINEXT_ORIGINAL_STACK_TRACE_ENDPOINT } from "./dev-stack-sourcemap-endpoint.js";
+import { VINEXT_ORIGINAL_STACK_TRACE_ENDPOINT } from "../utils/dev-stack-sourcemap-endpoint.js";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 //#region src/server/dev-stack-sourcemap.ts