vinext 1.0.0-beta.8 → 1.0.0

package/dist/server/pages-page-response.d.ts

@@ -8,8 +8,8 @@ import { ComponentType, ReactNode } from "react";
  * Returns true when the User-Agent belongs to a bot or crawler that cannot
  * reliably consume a streamed HTML response.
  */
-declare function isPagesStreamingBot(userAgent: string): boolean;
-declare function generatePagesETag(payload: string): string;
+export declare function isPagesStreamingBot(userAgent: string): boolean;
+export declare function generatePagesETag(payload: string): string;
 /**
  * Returns true when a request `Cache-Control` header asks to bypass the 304
  * short-circuit. Mirrors the `fresh` package's check used by Next.js's
@@ -17,7 +17,7 @@ declare function generatePagesETag(payload: string): string;
  * fresh-MISS bot path here and the ISR HIT/STALE paths in
  * `pages-page-data.ts` so the two cannot drift.
  */
-declare function requestsNoCache(cacheControl: string | undefined): boolean;
+export declare function requestsNoCache(cacheControl: string | undefined): boolean;
 type PagesFontPreload = {
   href: string;
   type: string;
@@ -29,14 +29,14 @@ type PagesFontPreload = {
  * recompute the initial `router.isReady`. Shared by every render path
  * (initial, ISR regeneration) so they emit identical readiness state.
  */
-type PagesNextDataExtras = Pick<VinextNextData, "__vinext" | "appGip" | "autoExport" | "gip" | "gsp" | "gssp" | "isExperimentalCompile" | "nextExport">;
-type PagesI18nRenderContext = {
+export type PagesNextDataExtras = Pick<VinextNextData, "__vinext" | "appGip" | "autoExport" | "gip" | "gsp" | "gssp" | "isExperimentalCompile" | "nextExport">;
+export type PagesI18nRenderContext = {
   locale?: string;
   locales?: string[];
   defaultLocale?: string;
   domainLocales?: unknown;
 };
-type PagesGsspResponse = {
+export type PagesGsspResponse = {
   headersSent?: boolean;
   statusCode: number;
   getHeaders(): Record<string, string | number | boolean | string[]>;
@@ -103,11 +103,16 @@ type RenderPagesPageResponseOptions = {
   query?: Record<string, unknown>;
   renderDocumentToString: (element: ReactNode) => Promise<string>;
   renderToReadableStream: (element: ReactNode) => Promise<ReadableStream<Uint8Array>>;
+  traceDocument?: <T extends {
+    bodyStream?: ReadableStream<Uint8Array>;
+    waitForBody?: boolean;
+  }>(callback: () => Promise<T>) => Promise<T>;
   resetSSRHead?: (() => void) | undefined;
   routePattern: string;
   routeUrl: string;
   safeJsonStringify: (value: unknown) => string;
   scriptNonce?: string;
+  initialStylesheetHrefs?: ReadonlySet<string>;
   crossOrigin?: string;
   disableOptimizedLoading: boolean;
   statusCode?: number;
@@ -136,9 +141,8 @@ type RenderPagesPageResponseOptions = {
    */
   requestCacheControl?: string;
 };
-declare function buildPagesNextDataScript(options: Pick<RenderPagesPageResponseOptions, "buildId" | "i18n" | "isFallback" | "pageProps" | "props" | "params" | "routePattern" | "safeJsonStringify" | "scriptNonce" | "nextData"> & {
+export declare function buildPagesNextDataScript(options: Pick<RenderPagesPageResponseOptions, "buildId" | "i18n" | "isFallback" | "pageProps" | "props" | "params" | "routePattern" | "safeJsonStringify" | "scriptNonce" | "nextData"> & {
   vinext?: VinextNextData["__vinext"];
 }): string;
-declare function renderPagesPageResponse(options: RenderPagesPageResponseOptions): Promise<Response>;
-//#endregion
-export { PagesGsspResponse, PagesI18nRenderContext, PagesNextDataExtras, buildPagesNextDataScript, generatePagesETag, isPagesStreamingBot, renderPagesPageResponse, requestsNoCache };
+export declare function renderPagesPageResponse(options: RenderPagesPageResponseOptions): Promise<Response>;
+//#endregion

package/dist/server/pages-page-response.js

@@ -1,5 +1,6 @@
+import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
-import { NEXTJS_CACHE_HEADER } from "./headers.js";
+import { NEXTJS_CACHE_HEADER, VINEXT_REVALIDATED_CACHE_TAG_HEADER } from "./headers.js";
 import { reportRequestError } from "./instrumentation.js";
 import { BROWSER_REVALIDATE_CACHE_CONTROL, NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders, shouldUseNextDeployCacheControl } from "./cache-control.js";
 import { buildMissIsrCacheControl } from "./isr-decision.js";
@@ -15,7 +16,6 @@ import { setCacheStateHeaders } from "./cache-headers.js";
 import { readStreamAsText } from "../utils/text-stream.js";
 import { loadUserDocumentInitialProps, runDocumentRenderPage } from "./pages-document-initial-props.js";
 import { callDocumentGetInitialProps } from "./document-initial-head.js";
-import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { matchesIfNoneMatch } from "./http-conditional.js";
 import React from "react";
 //#region src/server/pages-page-response.ts
@@ -119,14 +119,15 @@ async function buildPagesCompositeStream(bodyStream, shellPrefix, shellSuffix) {
 async function reportPagesIsrCacheWriteError(error, cacheKey, routePattern) {
 	console.error(`[vinext] Pages ISR cache write failed for ${cacheKey}:`, error);
 	try {
-		await reportRequestError(error instanceof Error ? error : new Error(String(error)), {
+		await reportRequestError(error, {
 			path: cacheKey,
 			method: "GET",
 			headers: {}
 		}, {
 			routerKind: "Pages Router",
 			routePath: routePattern,
-			routeType: "render"
+			routeType: "render",
+			revalidateReason: void 0
 		});
 	} catch {}
 }
@@ -181,33 +182,48 @@ async function renderPagesPageResponse(options) {
 		vinext: options.vinext
 	});
 	const bodyMarker = "<!--VINEXT_STREAM_BODY-->";
-	const documentRenderPage = await runDocumentRenderPage({
-		DocumentComponent: options.DocumentComponent,
-		enhancePageElement: options.enhancePageElement,
-		renderToReadableStream: options.renderToReadableStream,
-		renderStylesToString: async (element) => readStreamAsText(await options.renderToReadableStream(element)),
-		scriptNonce: options.scriptNonce,
-		context: {
-			err: options.err,
-			req: options.documentReqRes?.req,
-			res: options.documentReqRes?.res,
-			pathname: options.routePattern,
-			query: options.query ?? options.params,
-			asPath: options.routeUrl
+	const documentResult = await (options.traceDocument ?? ((callback) => callback()))(async () => {
+		const documentRenderPage = await runDocumentRenderPage({
+			DocumentComponent: options.DocumentComponent,
+			enhancePageElement: options.enhancePageElement,
+			renderToReadableStream: options.renderToReadableStream,
+			renderStylesToString: async (element) => readStreamAsText(await options.renderToReadableStream(element)),
+			scriptNonce: options.scriptNonce,
+			initialStylesheetHrefs: options.initialStylesheetHrefs,
+			context: {
+				err: options.err,
+				req: options.documentReqRes?.req,
+				res: options.documentReqRes?.res,
+				pathname: options.routePattern,
+				query: options.query ?? options.params,
+				asPath: options.routeUrl
+			}
+		});
+		if (options.documentReqRes?.res.headersSent && options.documentReqRes.responsePromise) return {
+			documentRenderPage,
+			responseSent: true
+		};
+		let bodyStream;
+		if (documentRenderPage.status === "rendered") bodyStream = new ReadableStream({ start(controller) {
+			controller.enqueue(new TextEncoder().encode(documentRenderPage.bodyHtml));
+			controller.close();
+		} });
+		else {
+			const pageElement = withScriptNonce(React.createElement(React.Fragment, null, options.createPageElement(renderProps)), options.scriptNonce, options.initialStylesheetHrefs);
+			bodyStream = await options.renderToReadableStream(pageElement);
 		}
+		if (documentRenderPage.status === "skipped") await callDocumentGetInitialProps(options.DocumentComponent, options.setDocumentInitialHead);
+		else options.setDocumentInitialHead?.(documentRenderPage.head);
+		return {
+			bodyStream,
+			documentRenderPage,
+			responseSent: false,
+			waitForBody: documentRenderPage.status === "skipped"
+		};
 	});
-	if (options.documentReqRes?.res.headersSent && options.documentReqRes.responsePromise) return options.documentReqRes.responsePromise;
-	let bodyStream;
-	if (documentRenderPage.status === "rendered") bodyStream = new ReadableStream({ start(controller) {
-		controller.enqueue(new TextEncoder().encode(documentRenderPage.bodyHtml));
-		controller.close();
-	} });
-	else {
-		const pageElement = withScriptNonce(React.createElement(React.Fragment, null, options.createPageElement(renderProps)), options.scriptNonce);
-		bodyStream = await options.renderToReadableStream(pageElement);
-	}
-	if (documentRenderPage.status === "skipped") await callDocumentGetInitialProps(options.DocumentComponent, options.setDocumentInitialHead);
-	else options.setDocumentInitialHead?.(documentRenderPage.head);
+	if (documentResult.responseSent && options.documentReqRes?.responsePromise) return options.documentReqRes.responsePromise;
+	const { bodyStream, documentRenderPage } = documentResult;
+	if (!bodyStream) throw new Error("Pages document render did not produce a body stream");
 	const headFromShim = options.getSSRHeadHTML?.() ?? "";
 	const traceMetaHTML = getClientTraceMetadataHTML(options.clientTraceMetadata);
 	const ssrHeadHTML = headFromShim;
@@ -263,8 +279,10 @@ async function renderPagesPageResponse(options) {
 			cacheControl: buildMissIsrCacheControl(options.isrRevalidateSeconds, options.expireSeconds),
 			tags: [encodeCacheTag(`_N_T_${stem || "/"}`)]
 		});
-		if (options.isOnDemandRevalidate) responseHeaders.set(NEXTJS_CACHE_HEADER, "REVALIDATED");
-		else setCacheStateHeaders(responseHeaders, "MISS");
+		if (options.isOnDemandRevalidate) {
+			responseHeaders.set(NEXTJS_CACHE_HEADER, "REVALIDATED");
+			responseHeaders.set(VINEXT_REVALIDATED_CACHE_TAG_HEADER, encodeCacheTag(`_N_T_${stem || "/"}`));
+		} else setCacheStateHeaders(responseHeaders, "MISS");
 	} else if (options.isStaticPropsRoute && shouldUseNextDeployCacheControl()) responseHeaders.set("Cache-Control", BROWSER_REVALIDATE_CACHE_CONTROL);
 	else if (options.gsspRes && !userSetCacheControl) responseHeaders.set("Cache-Control", NEVER_CACHE_CONTROL);
 	if (options.fontLinkHeader) responseHeaders.set("Link", options.fontLinkHeader);

package/dist/server/pages-preview.d.ts

@@ -1,7 +1,7 @@
 //#region src/server/pages-preview.d.ts
-declare const PAGES_PREVIEW_CACHE_CONTROL = "private, no-cache, no-store, max-age=0, must-revalidate";
-type PagesPreviewData = object | string;
-type PagesPreviewState = {
+export declare const PAGES_PREVIEW_CACHE_CONTROL = "private, no-cache, no-store, max-age=0, must-revalidate";
+export type PagesPreviewData = object | string;
+export type PagesPreviewState = {
   data: PagesPreviewData | false;
   shouldClear: boolean;
 };
@@ -9,18 +9,17 @@ type PreviewResponse = {
   getHeader(name: string): string | number | boolean | string[] | undefined;
   setHeader(name: string, value: string | number | boolean | string[]): unknown;
 };
-declare function getPagesPreviewModeId(): string;
-declare function getPagesPreviewState(cookieHeader: string | string[] | null | undefined, options?: {
+export declare function getPagesPreviewModeId(): string;
+export declare function getPagesPreviewState(cookieHeader: string | string[] | null | undefined, options?: {
   isOnDemandRevalidate?: boolean;
 }): PagesPreviewState;
-declare function setPagesDraftMode(response: PreviewResponse, enabled: boolean): void;
-declare function setPagesPreviewData(response: PreviewResponse, data: PagesPreviewData, options?: {
+export declare function setPagesDraftMode(response: PreviewResponse, enabled: boolean): void;
+export declare function setPagesPreviewData(response: PreviewResponse, data: PagesPreviewData, options?: {
   maxAge?: number;
   path?: string;
 }): void;
-declare function clearPagesPreviewData(response: PreviewResponse, options?: {
+export declare function clearPagesPreviewData(response: PreviewResponse, options?: {
   path?: string;
 }): void;
-declare function appendPagesPreviewClearCookies(headers: Headers): void;
-//#endregion
-export { PAGES_PREVIEW_CACHE_CONTROL, PagesPreviewData, PagesPreviewState, appendPagesPreviewClearCookies, clearPagesPreviewData, getPagesPreviewModeId, getPagesPreviewState, setPagesDraftMode, setPagesPreviewData };
+export declare function appendPagesPreviewClearCookies(headers: Headers): void;
+//#endregion

package/dist/server/pages-readiness.d.ts

@@ -24,7 +24,7 @@ type PagesReadinessNextData = Pick<VinextNextData, "gssp" | "gsp" | "gip" | "app
  * Build the readiness flags for a Pages Router render. Shared by the dev and
  * production Pages render paths.
  */
-declare function buildPagesReadinessNextData(options: {
+export declare function buildPagesReadinessNextData(options: {
   pageModule: PagesPageModule;
   appComponent: {
     getInitialProps?: unknown;
@@ -32,5 +32,4 @@ declare function buildPagesReadinessNextData(options: {
   } | null | undefined;
   hasRewrites: boolean;
 }): PagesReadinessNextData;
-//#endregion
-export { buildPagesReadinessNextData };
+//#endregion

package/dist/server/pages-request-pipeline.d.ts

@@ -1,22 +1,25 @@
 import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config/next-config.js";
+import { PagesRouteDataKind } from "./pages-route-data-kind.js";
 import { HeaderRecord } from "./request-pipeline.js";
 //#region src/server/pages-request-pipeline.d.ts
-type PagesRenderOptions = {
+export type PagesRenderOptions = {
   isDataReq?: boolean;
   renderErrorPageOnMiss?: boolean;
   originalUrl?: string;
 };
-type FilesystemRoutePhase = "direct" | "beforeFiles" | "afterFiles" | "fallback";
+export type FilesystemRoutePhase = "direct" | "beforeFiles" | "afterFiles" | "fallback";
 type PageRouteMatch = {
   route: {
     isDynamic: boolean;
     pattern?: string;
-    dataKind?: "static" | "server" | "none";
+    dataKind?: PagesRouteDataKind;
   };
 };
-declare function fetchWorkerFilesystemRoute(request: Request, requestPathname: string, phase: FilesystemRoutePhase, fetchAsset: (request: Request) => Promise<Response>, publicFiles?: ReadonlySet<string>, isDirectBuildAsset?: boolean): Promise<Response | false>;
-type MiddlewareResult = {
+export declare function fetchWorkerFilesystemRoute(request: Request, requestPathname: string, phase: FilesystemRoutePhase, fetchAsset: (request: Request) => Promise<Response>, publicFiles?: ReadonlySet<string>, isDirectBuildAsset?: boolean): Promise<Response | false>;
+export type MiddlewareResult = {
   continue: boolean;
+  /** The pathname matches middleware, irrespective of request `has`/`missing` conditions. */
+  pathnameEligible?: boolean;
   redirectUrl?: string;
   redirectStatus?: number;
   rewriteUrl?: string;
@@ -26,7 +29,7 @@ type MiddlewareResult = {
   response?: Response;
   waitUntilPromises?: Promise<unknown>[];
 };
-type PagesPipelineDeps = {
+export type PagesPipelineDeps = {
   basePath: string;
   trailingSlash: boolean;
   i18nConfig: NextI18nConfig | null;
@@ -42,6 +45,8 @@ type PagesPipelineDeps = {
   isDataRequest: boolean;
   hasMiddleware: boolean;
   ctx?: unknown;
+  /** False when routing and middleware run outside the shared response stage. */
+  recordCacheability?: boolean;
   rawSearch?: string;
   configMatchPathname?: string;
   /**
@@ -67,7 +72,7 @@ type PagesPipelineDeps = {
   /** Stale/malformed data response emitted only if middleware does not handle the request. */
   dataNotFoundResponse?: Response | null;
   renderPage?: ((request: Request, resolvedUrl: string, options?: PagesRenderOptions, stagedHeaders?: Headers) => Promise<Response>) | null;
-  handleApi?: ((request: Request, apiUrl: string, ctx: unknown) => Promise<Response>) | null;
+  handleApi?: ((request: Request, apiUrl: string, ctx: unknown, stagedHeaders: Headers) => Promise<Response>) | null;
   /**
    * Optional override for proxying external rewrite destinations.
    * When supplied, the pipeline calls this instead of proxyExternalRequest(currentRequest, url).
@@ -98,8 +103,8 @@ type PagesPipelineDeps = {
  * Shared by the Node prod server (prod-server.ts) and the generated Pages
  * Router worker entry (deploy.ts) to keep the two adapters in sync.
  */
-declare function wrapMiddlewareWithBasePath(runMiddleware: NonNullable<PagesPipelineDeps["runMiddleware"]>, basePath: string, hadBasePath: boolean): NonNullable<PagesPipelineDeps["runMiddleware"]>;
-type PagesPipelineResult = {
+export declare function wrapMiddlewareWithBasePath(runMiddleware: NonNullable<PagesPipelineDeps["runMiddleware"]>, basePath: string, hadBasePath: boolean): NonNullable<PagesPipelineDeps["runMiddleware"]>;
+export type PagesPipelineResult = {
   type: "response";
   response: Response;
   defaultContentType?: string;
@@ -137,6 +142,5 @@ type PagesPipelineResult = {
  * decode/normalize/400, public-file serving.
  * runPagesRequest receives a "clean" request with basePath-stripped URL.
  */
-declare function runPagesRequest(request: Request, deps: PagesPipelineDeps): Promise<PagesPipelineResult>;
-//#endregion
-export { FilesystemRoutePhase, MiddlewareResult, PagesPipelineDeps, PagesPipelineResult, PagesRenderOptions, fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath };
+export declare function runPagesRequest(request: Request, deps: PagesPipelineDeps): Promise<PagesPipelineResult>;
+//#endregion

package/dist/server/pages-request-pipeline.js

@@ -1,18 +1,35 @@
-import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
-import { patternToNextFormat } from "../routing/route-validation.js";
-import { requestContextFromRequest } from "../config/request-context.js";
 import { PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
+import { requestContextFromRequest } from "../config/request-context.js";
 import { isExternalUrl } from "../utils/external-url.js";
 import { applyMiddlewareRequestHeaders, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, sanitizeDestination } from "../config/config-matchers.js";
+import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
+import { patternToNextFormat } from "../routing/route-validation.js";
 import { methodNotAllowedResponse, sanitizeMethodNotAllowedHeaders } from "./http-error-responses.js";
 import { cloneRequestWithUrl, normalizeTrailingSlash } from "./request-pipeline.js";
 import { normalizeDefaultLocalePathname, stripI18nLocaleForApiRoute } from "./pages-i18n.js";
-import { isOnDemandRevalidateRequest } from "./isr-cache.js";
+import { markRouteCacheabilityDynamic } from "../shims/cacheability-classification.js";
+import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
 import { mergeRewriteQuery } from "../utils/query.js";
 import { buildMiddlewarePrefetchSkipResponse } from "./pages-data-route.js";
+import { setFrameworkRequestRoute } from "./request-tracing.js";
 import { applyConfigHeadersToHeaderRecord } from "./config-headers.js";
 import { mergeHeaders } from "./worker-utils.js";
 //#region src/server/pages-request-pipeline.ts
+function ruleUsesUnkeyedRequestCondition(rule) {
+	return [...rule.has ?? [], ...rule.missing ?? []].some((condition) => condition.type === "header" || condition.type === "cookie" || condition.type === "host");
+}
+function markConditionalRewriteCacheability(rewrite) {
+	if (ruleUsesUnkeyedRequestCondition(rewrite)) markRouteCacheabilityDynamic("next.config rewrite depends on request headers, cookies, or hostnames");
+}
+function markConditionalRedirectCacheability(redirect) {
+	if (ruleUsesUnkeyedRequestCondition(redirect)) markRouteCacheabilityDynamic("next.config redirect depends on request headers, cookies, or hostnames");
+}
+function headersFromRecord(record) {
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(record)) if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+	else headers.set(name, value);
+	return headers;
+}
 async function fetchWorkerFilesystemRoute(request, requestPathname, phase, fetchAsset, publicFiles, isDirectBuildAsset = false) {
 	const isRetrievalMethod = request.method === "GET" || request.method === "HEAD";
 	if (phase === "direct" && isRetrievalMethod || phase === "direct" && publicFiles !== void 0 && !isDirectBuildAsset && !publicFiles.has(requestPathname) || requestPathname === "/api" || requestPathname.startsWith("/api/")) return false;
@@ -64,6 +81,8 @@ function wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) {
 */
 async function runPagesRequest(request, deps) {
 	const { basePath, trailingSlash, i18nConfig, configRedirects, configRewrites, configHeaders, hadBasePath, isDataReq, isDataRequest } = deps;
+	const conditionalRedirectCacheability = deps.recordCacheability === false ? void 0 : markConditionalRedirectCacheability;
+	const conditionalRewriteCacheability = deps.recordCacheability === false ? void 0 : markConditionalRewriteCacheability;
 	const proxyExternal = (currentReq, externalUrl) => deps.proxyExternal ? deps.proxyExternal(currentReq, externalUrl) : proxyExternalRequest(currentReq, externalUrl);
 	const url = new URL(request.url);
 	let pathname = url.pathname;
@@ -86,9 +105,10 @@ async function runPagesRequest(request, deps) {
 	const requestHostname = i18nConfig ? url.hostname : "";
 	const requestConfigMatchPathname = i18nConfig ? normalizeDefaultLocalePathname(requestConfigPathname, i18nConfig, { hostname: requestHostname }) : requestConfigPathname;
 	if (configRedirects.length) {
-		const redirect = matchRedirect(requestConfigMatchPathname, configRedirects, reqCtx, basePathState);
+		const redirect = matchRedirect(requestConfigMatchPathname, configRedirects, reqCtx, basePathState, conditionalRedirectCacheability);
 		if (redirect) {
-			const location = preserveRedirectDestinationQuery(sanitizeDestination(basePath && hadBasePath && !isExternalUrl(redirect.destination) && !hasBasePath(redirect.destination, basePath) ? basePath + redirect.destination : redirect.destination), deps.rawSearch ?? search);
+			const dest = sanitizeDestination(basePath && hadBasePath && !isExternalUrl(redirect.destination) && !hasBasePath(redirect.destination, basePath) ? basePath + redirect.destination : redirect.destination);
+			const location = preserveRedirectDestinationQuery(dest, deps.rawSearch ?? search);
 			return {
 				type: "response",
 				response: new Response(null, {
@@ -102,6 +122,18 @@ async function runPagesRequest(request, deps) {
 	let resolvedUrl = originalResolvedUrl;
 	let resolvedPathnameIsRequestPathname = true;
 	const middlewareHeaders = {};
+	const mergeConfigHeadersIntoEarlyResponse = (response) => {
+		if (configHeaders.length === 0) return response;
+		const matchedConfigHeaders = {};
+		applyConfigHeadersToHeaderRecord(matchedConfigHeaders, {
+			configHeaders,
+			pathname: requestConfigMatchPathname,
+			requestContext: reqCtx,
+			basePathState,
+			recordCacheability: deps.recordCacheability
+		});
+		return mergeHeaders(response, matchedConfigHeaders);
+	};
 	let middlewareStatus;
 	const serveFilesystemRoute = async (requestPathname, phase) => {
 		if (!deps.serveFilesystemRoute) return null;
@@ -119,6 +151,7 @@ async function runPagesRequest(request, deps) {
 	};
 	if (!isOnDemandRevalidate && typeof deps.runMiddleware === "function") {
 		const result = await deps.runMiddleware(deps.middlewareRequest ?? request, deps.ctx ?? null, { isDataRequest });
+		if (deps.recordCacheability !== false && result.pathnameEligible) markRouteCacheabilityDynamic("middleware can match this pathname");
 		if (result.waitUntilPromises && result.waitUntilPromises.length > 0) {
 			const ctx = deps.ctx;
 			if (ctx && typeof ctx.waitUntil === "function") for (const p of result.waitUntilPromises) ctx.waitUntil(p);
@@ -138,15 +171,15 @@ async function runPagesRequest(request, deps) {
 				else headers.set(k, v);
 				return {
 					type: "response",
-					response: new Response(null, {
+					response: mergeConfigHeadersIntoEarlyResponse(new Response(null, {
 						status: result.redirectStatus ?? 307,
 						headers
-					})
+					}))
 				};
 			}
 			if (result.response) return {
 				type: "response",
-				response: result.response
+				response: mergeConfigHeadersIntoEarlyResponse(result.response)
 			};
 		}
 		if (result.responseHeaders) for (const [key, value] of result.responseHeaders) if (key === "set-cookie") {
@@ -195,15 +228,19 @@ async function runPagesRequest(request, deps) {
 		configHeaders,
 		pathname: requestConfigMatchPathname,
 		requestContext: reqCtx,
-		basePathState
+		basePathState,
+		recordCacheability: deps.recordCacheability
 	});
-	if (isExternalUrl(resolvedUrl)) return {
-		type: "response",
-		response: mergeHeaders(await proxyExternal(request, resolvedUrl), middlewareHeaders, void 0)
-	};
+	if (isExternalUrl(resolvedUrl)) {
+		const proxyResponse = await proxyExternal(request, resolvedUrl);
+		return {
+			type: "response",
+			response: mergeHeaders(proxyResponse, middlewareHeaders, void 0)
+		};
+	}
 	let configRewriteFired = false;
 	for (const rewrite of configRewrites.beforeFiles ?? []) {
-		const rewritten = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState);
+		const rewritten = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState, configSourcePathname(), conditionalRewriteCacheability);
 		if (rewritten) {
 			if (isExternalUrl(rewritten)) return {
 				type: "response",
@@ -230,7 +267,9 @@ async function runPagesRequest(request, deps) {
 		const apiLookupUrl = stripI18nLocaleForApiRoute(resolvedUrl, i18nConfig);
 		const apiLookupPathname = apiLookupUrl.split("?")[0];
 		if (!apiLookupPathname.startsWith("/api/") && apiLookupPathname !== "/api") return null;
-		if (deps.matchApiRoute && !await deps.matchApiRoute(apiLookupUrl, request)) return null;
+		const apiMatch = deps.matchApiRoute ? await deps.matchApiRoute(apiLookupUrl, request) : null;
+		if (deps.matchApiRoute && !apiMatch) return null;
+		if (apiMatch) setFrameworkRequestRoute(matchedPathnameForRoute(apiMatch.route.pattern));
 		if (typeof deps.handleApi === "function") {
 			let apiRequest = request;
 			if (basePath && hadBasePath) {
@@ -238,7 +277,7 @@ async function runPagesRequest(request, deps) {
 				apiRequestUrl.pathname = addBasePathToPathname(apiRequestUrl.pathname, basePath);
 				apiRequest = cloneRequestWithUrl(request, apiRequestUrl.toString());
 			}
-			const response = await deps.handleApi(apiRequest, apiLookupUrl, deps.ctx ?? null);
+			const response = await deps.handleApi(apiRequest, apiLookupUrl, deps.ctx ?? null, headersFromRecord(middlewareHeaders));
 			const merged = mergeHeaders(response, middlewareHeaders, middlewareStatus);
 			if (merged !== response) merged.__vinextStreamedApiResponse = response.__vinextStreamedApiResponse;
 			return {
@@ -261,7 +300,7 @@ async function runPagesRequest(request, deps) {
 	let pageMatch = !isOutsideBasePathUnclaimed() && deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
 	let resolvedPathnameChanged = false;
 	if (!pageMatch || pageMatch.route.isDynamic) for (const rewrite of configRewrites.afterFiles ?? []) {
-		const rewritten = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState);
+		const rewritten = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState, configSourcePathname(), conditionalRewriteCacheability);
 		if (rewritten) {
 			if (isExternalUrl(rewritten)) return {
 				type: "response",
@@ -288,7 +327,7 @@ async function runPagesRequest(request, deps) {
 	if (typeof deps.renderPage === "function") {
 		let renderPageMatch = pageMatch;
 		if ((isOutsideBasePathUnclaimed() || isDataReq || isDataRequest) && !renderPageMatch && configRewrites.fallback?.length) for (const rewrite of configRewrites.fallback) {
-			const fallbackRewrite = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState);
+			const fallbackRewrite = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState, configSourcePathname(), conditionalRewriteCacheability);
 			if (!fallbackRewrite) continue;
 			if (isExternalUrl(fallbackRewrite)) return {
 				type: "response",
@@ -311,13 +350,12 @@ async function runPagesRequest(request, deps) {
 		if (isOutsideBasePathUnclaimed()) return outOfBasePathNotFound();
 		const shouldDeferErrorPageOnMiss = !isDataReq && !isDataRequest && !!deps.matchPageRoute && !renderPageMatch;
 		const initialRenderOptions = shouldDeferErrorPageOnMiss ? { renderErrorPageOnMiss: false } : isDataReq ? { isDataReq: true } : void 0;
-		const stagedHeaders = new Headers();
-		for (const [k, v] of Object.entries(middlewareHeaders)) if (Array.isArray(v)) for (const item of v) stagedHeaders.append(k, item);
-		else stagedHeaders.set(k, v);
+		const stagedHeaders = headersFromRecord(middlewareHeaders);
+		if (renderPageMatch) setFrameworkRequestRoute(matchedPathnameForRoute(renderPageMatch.route.pattern));
 		let response = await deps.renderPage(request, resolvedUrl, initialRenderOptions, stagedHeaders);
 		let matchedFallbackRewrite = false;
 		if (response.status === 404 && shouldDeferErrorPageOnMiss && configRewrites.fallback?.length) for (const rewrite of configRewrites.fallback) {
-			const fallbackRewrite = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState);
+			const fallbackRewrite = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState, configSourcePathname(), conditionalRewriteCacheability);
 			if (!fallbackRewrite) continue;
 			if (isExternalUrl(fallbackRewrite)) return {
 				type: "response",
@@ -332,6 +370,7 @@ async function runPagesRequest(request, deps) {
 			const fallbackApiResult = await handleResolvedApiRoute();
 			if (fallbackApiResult) return fallbackApiResult;
 			renderPageMatch = deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
+			if (renderPageMatch) setFrameworkRequestRoute(matchedPathnameForRoute(renderPageMatch.route.pattern));
 			response = await deps.renderPage(request, resolvedUrl, void 0, stagedHeaders);
 			matchedFallbackRewrite = true;
 			if (response.status !== 404) break;
@@ -342,12 +381,13 @@ async function runPagesRequest(request, deps) {
 			const headers = new Headers(response.headers);
 			headers.set("content-type", "application/json");
 			headers.set("x-nextjs-matched-path", matchResolvedPathname(pathname));
+			const notFoundResponse = new Response("{}", {
+				status: 200,
+				headers
+			});
 			return {
 				type: "response",
-				response: mergeHeaders(new Response("{}", {
-					status: 200,
-					headers
-				}), matchedPathHeaders, void 0),
+				response: mergeHeaders(notFoundResponse, matchedPathHeaders, void 0),
 				defaultContentType: "application/json"
 			};
 		}
@@ -362,7 +402,7 @@ async function runPagesRequest(request, deps) {
 	}
 	let devPageMatch = isOutsideBasePathUnclaimed() ? null : resolvedPathnameChanged ? deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null : pageMatch;
 	if (!devPageMatch && configRewrites.fallback?.length) for (const rewrite of configRewrites.fallback) {
-		const fallbackRewrite = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState);
+		const fallbackRewrite = matchRewrite(configSourcePathname(), [rewrite], rewriteRequestContext(), basePathState, configSourcePathname(), conditionalRewriteCacheability);
 		if (!fallbackRewrite) continue;
 		if (isExternalUrl(fallbackRewrite)) return {
 			type: "response",
@@ -383,6 +423,7 @@ async function runPagesRequest(request, deps) {
 	if (prefetchSkipResult) return prefetchSkipResult;
 	if (isOutsideBasePathUnclaimed()) return outOfBasePathNotFound();
 	refreshDataRewriteHeader();
+	if (devPageMatch) setFrameworkRequestRoute(matchedPathnameForRoute(devPageMatch.route.pattern));
 	return {
 		type: "render",
 		resolvedUrl,

package/dist/server/pages-request-stage-entry.d.ts

@@ -0,0 +1,23 @@
+import { VinextRequestStageContext } from "./multi-stage.js";
+import { ExecutionContextLike } from "../shims/request-context.js";
+import { DispatchWorkerResponseStage, WorkerResponseStageProps } from "./worker-stages.js";
+//#region src/server/pages-request-stage-entry.d.ts
+type AssetFetcher = {
+  fetch(request: Request): Promise<Response> | Response;
+};
+export type PagesWorkerEnv = {
+  ASSETS?: AssetFetcher;
+} & Record<string, unknown>;
+export type PagesWorkerExecutionContext = {
+  waitUntil?(promise: Promise<unknown>): void;
+  passThroughOnException?(): void;
+  cache?: unknown;
+} & VinextRequestStageContext;
+export type PagesLocalResponseStage = (request: Request, env: PagesWorkerEnv | undefined, ctx: ExecutionContextLike, props: WorkerResponseStageProps) => Promise<Response>;
+export declare const pagesRequestStageBuildId: string | null;
+export declare const pagesRequestStagePrerenderSecret: string | null;
+/** Run the request-time stage with a host-owned response dispatcher. */
+export declare function handleRequestStage(request: Request, env: PagesWorkerEnv | undefined, ctx: PagesWorkerExecutionContext | undefined, dispatchResponseStage: DispatchWorkerResponseStage): Promise<Response>;
+/** Preserve the direct single-entry Worker path without retaining it in request-only builds. */
+export declare function handleRequestStageLocally(request: Request, env: PagesWorkerEnv | undefined, ctx: PagesWorkerExecutionContext | undefined, dispatchResponseStage: PagesLocalResponseStage): Promise<Response>;
+//#endregion