vinext 0.1.2 → 0.1.3

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

@@ -31,6 +31,7 @@ type VinextConfigSubset = {
   assetPrefix: string;
   trailingSlash: boolean;
   expireTime?: number;
+  htmlLimitedBots?: string;
   clientTraceMetadata?: readonly string[];
   disableOptimizedLoading: boolean;
 };
@@ -73,8 +74,8 @@ type CreatePagesPageHandlerOptions = {
   renderIsrPassToStringAsync: (element: ReactNode) => Promise<string>; /** `safeJsonStringify` from `vinext/html`. */
   safeJsonStringify: (value: unknown) => string; /** `sanitizeDestination` from the config-matchers module. */
   sanitizeDestination: (dest: string) => string; /** Build the React page element for a given set of page props. */
-  createPageElement: (PageComponent: ComponentType, AppComponent: ComponentType | null, pageProps: Record<string, unknown>) => ReactNode; /** Build the element with optional App/Component enhancers (for _document). */
-  enhancePageElement: (PageComponent: ComponentType, AppComponent: ComponentType | null, pageProps: Record<string, unknown>, opts: RenderPageEnhancers) => ReactNode; /** The `_app` page component (or null). */
+  createPageElement: (PageComponent: ComponentType, AppComponent: ComponentType | null, props: Record<string, unknown>) => ReactNode; /** Build the element with optional App/Component enhancers (for _document). */
+  enhancePageElement: (PageComponent: ComponentType, AppComponent: ComponentType | null, props: Record<string, unknown>, opts: RenderPageEnhancers) => ReactNode; /** The `_app` page component (or null). */
   AppComponent: ComponentType | null; /** The `_document` page component (or null). */
   DocumentComponent: ComponentType | null;
 };
@@ -82,6 +83,7 @@ type RenderPageOptions = {
   isDataReq?: boolean;
   statusCode?: number;
   asPath?: string;
+  originalUrl?: string;
   renderErrorPageOnMiss?: boolean;
   __isInternalErrorRender?: boolean;
   __forcedRoute?: PageRoute;

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

@@ -7,13 +7,14 @@ import { NEVER_CACHE_CONTROL } from "./cache-control.js";
 import "./isr-decision.js";
 import { PRERENDER_REVALIDATE_HEADER, isOnDemandRevalidateRequest, isrCacheKey, isrGet, isrSet, triggerBackgroundRegeneration } from "./isr-cache.js";
 import { ensureFetchPatch } from "../shims/fetch-cache.js";
+import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
 import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { resolvePagesI18nRequest } from "./pages-i18n.js";
 import { buildDefaultPagesNotFoundResponse } from "./pages-default-404.js";
 import { buildPagesReadinessNextData } from "./pages-readiness.js";
 import { resolvePagesPageMethodResponse } from "./pages-page-method.js";
-import { buildNextDataJsonResponse, buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
+import { buildNextDataNotFoundResponse, buildNextDataPropsJsonResponse, normalizePagesDataRequest, parseNextDataPathname } from "./pages-data-route.js";
 import { createPagesReqRes } from "./pages-node-compat.js";
 import { collectAssetTags, resolveClientModuleUrl } from "./pages-asset-tags.js";
 import { renderPagesPageResponse } from "./pages-page-response.js";
@@ -48,19 +49,38 @@ function createPagesPageHandler(opts) {
 	}
 	async function renderPage(request, url, manifest, middlewareHeaders, options) {
 		let isDataReq = !!(options && options.isDataReq);
+		const requestUrl = new URL(request.url);
+		const rawOriginalUrl = options && typeof options.originalUrl === "string" ? options.originalUrl : requestUrl.pathname + requestUrl.search;
+		const originalRequestUrl = new URL(rawOriginalUrl, requestUrl);
+		const originalRequestPathAndSearch = originalRequestUrl.pathname + originalRequestUrl.search;
+		let dataRequestPathname = null;
+		let dataRequestSearch = "";
+		const initialDataNorm = normalizePagesDataRequest(request, buildId);
 		if (!isDataReq) {
-			const dataNorm = normalizePagesDataRequest(request, buildId);
-			if (dataNorm.notFoundResponse) return dataNorm.notFoundResponse;
-			if (dataNorm.isDataReq) {
+			if (initialDataNorm.notFoundResponse) return initialDataNorm.notFoundResponse;
+			if (initialDataNorm.isDataReq) {
 				isDataReq = true;
+				dataRequestPathname = initialDataNorm.normalizedPathname;
+				dataRequestSearch = initialDataNorm.search;
 				if (url && url.startsWith("/_next/data/")) {
 					const qs = url.includes("?") ? url.slice(url.indexOf("?")) : "";
-					url = dataNorm.normalizedPathname + qs;
+					url = initialDataNorm.normalizedPathname + qs;
 				}
 			}
+		} else if (initialDataNorm.isDataReq) {
+			dataRequestPathname = initialDataNorm.normalizedPathname;
+			dataRequestSearch = initialDataNorm.search;
+		}
+		if (isDataReq && dataRequestPathname === null && buildId) {
+			const originalDataMatch = parseNextDataPathname(originalRequestUrl.pathname, buildId);
+			if (originalDataMatch) {
+				dataRequestPathname = originalDataMatch.pagePathname;
+				dataRequestSearch = originalRequestUrl.search;
+			}
 		}
 		const statusCode = options && typeof options.statusCode === "number" ? options.statusCode : void 0;
-		const asPath = options && typeof options.asPath === "string" ? options.asPath : void 0;
+		const defaultAsPath = isDataReq && dataRequestPathname ? dataRequestPathname + dataRequestSearch : originalRequestPathAndSearch;
+		const asPath = options && typeof options.asPath === "string" ? options.asPath : defaultAsPath;
 		const renderErrorPageOnMiss = !(options && options.renderErrorPageOnMiss === false);
 		const isInternalErrorRender = !!(options && options.__isInternalErrorRender);
 		const err = options && options.err;
@@ -143,8 +163,8 @@ function createPagesPageHandler(opts) {
 					});
 					if (methodResponse) return methodResponse;
 				}
-				const pageModuleUrl = resolveClientModuleUrl(manifest, route.filePath, vinextConfig.basePath, vinextConfig.assetPrefix);
-				const appModuleUrl = resolveClientModuleUrl(manifest, appAssetPath, vinextConfig.basePath, vinextConfig.assetPrefix);
+				const pageModuleUrl = resolveClientModuleUrl(manifest, route.filePath, vinextConfig.basePath, vinextConfig.assetPrefix, process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID);
+				const appModuleUrl = resolveClientModuleUrl(manifest, appAssetPath, vinextConfig.basePath, vinextConfig.assetPrefix, process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID);
 				const serializedPagesNextData = {
 					...pagesNextData,
 					__vinext: {
@@ -159,24 +179,30 @@ function createPagesPageHandler(opts) {
 				let allFontPreloads = [];
 				try {
 					allFontPreloads = getFontPreloads();
-					if (allFontPreloads.length > 0) fontLinkHeader = allFontPreloads.map((p) => "<" + p.href + ">; rel=preload; as=font; type=" + p.type + "; crossorigin").join(", ");
+					if (allFontPreloads.length > 0) fontLinkHeader = allFontPreloads.map((p) => "<" + appendAssetDeploymentIdQuery(p.href) + ">; rel=preload; as=font; type=" + p.type + "; crossorigin").join(", ");
 				} catch {}
+				const pagesResolvedUrl = (new URL(routeUrl, originalRequestUrl).pathname || "/") + originalRequestUrl.search;
 				const pageDataResult = await resolvePagesPageData({
 					isDataReq,
 					err,
 					applyRequestContexts: applySSRContext,
 					buildId,
 					deploymentId: process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID,
+					htmlLimitedBots: vinextConfig.htmlLimitedBots,
 					createGsspReqRes() {
 						return createPagesReqRes({
 							body: void 0,
 							query,
 							request,
-							url: routeUrl
+							url: originalRequestPathAndSearch
 						});
 					},
-					createPageElement(currentPageProps) {
-						const el = createPageElement(PageComponent, AppComponent, currentPageProps);
+					createAppTree(appTreeProps) {
+						const el = createPageElement(PageComponent, AppComponent, appTreeProps);
+						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
+					},
+					createPageElement(currentProps) {
+						const el = createPageElement(PageComponent, AppComponent, currentProps);
 						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
 					},
 					fontLinkHeader,
@@ -188,15 +214,17 @@ function createPagesPageHandler(opts) {
 					isBuildTimePrerendering: typeof process !== "undefined" && process.env && process.env.VINEXT_PRERENDER === "1",
 					isOnDemandRevalidate: isOnDemandRevalidateRequest(request.headers.get(PRERENDER_REVALIDATE_HEADER)),
 					pageModule,
+					AppComponent,
 					params,
 					query,
 					asPath: renderAsPath ?? routeUrl,
+					resolvedUrl: pagesResolvedUrl,
 					renderIsrPassToStringAsync,
 					route: { isDynamic: route.isDynamic },
 					routePattern,
 					routeUrl,
 					runInFreshUnifiedContext(callback) {
-						return runWithRequestContext(createRequestContext({ executionContext: getRequestExecutionContext() }), async () => {
+						return runWithRequestContext(createRequestContext({ executionContext: null }), async () => {
 							ensureFetchPatch();
 							return callback();
 						});
@@ -224,10 +252,17 @@ function createPagesPageHandler(opts) {
 				}
 				if (pageDataResult.kind === "response") return pageDataResult.response;
 				let pageProps = pageDataResult.pageProps;
-				if (routePattern === "/_error" && typeof renderStatusCode === "number") pageProps = {
-					...pageProps,
-					statusCode: renderStatusCode
-				};
+				let renderProps = pageDataResult.props;
+				if (routePattern === "/_error" && typeof renderStatusCode === "number") {
+					pageProps = {
+						...pageProps,
+						statusCode: renderStatusCode
+					};
+					renderProps = {
+						...renderProps,
+						pageProps
+					};
+				}
 				const gsspRes = pageDataResult.gsspRes;
 				const isrRevalidateSeconds = pageDataResult.isrRevalidateSeconds;
 				const isFallbackRender = pageDataResult.isFallback === true;
@@ -264,7 +299,7 @@ function createPagesPageHandler(opts) {
 						const deploymentId = process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID;
 						if (deploymentId) init.headers[NEXTJS_DEPLOYMENT_ID_HEADER] = deploymentId;
 					}
-					return buildNextDataJsonResponse(pageProps, safeJsonStringify, init);
+					return buildNextDataPropsJsonResponse(renderProps, safeJsonStringify, init);
 				}
 				const pageModuleIds = [];
 				if (route.filePath) pageModuleIds.push(route.filePath);
@@ -276,18 +311,19 @@ function createPagesPageHandler(opts) {
 						scriptNonce,
 						disableOptimizedLoading: vinextConfig.disableOptimizedLoading,
 						basePath: vinextConfig.basePath,
-						assetPrefix: vinextConfig.assetPrefix
+						assetPrefix: vinextConfig.assetPrefix,
+						deploymentId: process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID
 					}),
 					buildId,
 					clearSsrContext() {
 						if (typeof setSSRContext === "function") setSSRContext(null);
 					},
-					createPageElement(currentPageProps) {
-						const el = createPageElement(PageComponent, AppComponent, currentPageProps);
+					createPageElement(currentProps) {
+						const el = createPageElement(PageComponent, AppComponent, currentProps);
 						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
 					},
 					enhancePageElement(renderPageOpts) {
-						const el = enhancePageElement(PageComponent, AppComponent, pageProps, renderPageOpts);
+						const el = enhancePageElement(PageComponent, AppComponent, renderProps, renderPageOpts);
 						return typeof wrapWithRouterContext === "function" ? wrapWithRouterContext(el) : el;
 					},
 					DocumentComponent,
@@ -306,6 +342,7 @@ function createPagesPageHandler(opts) {
 					i18n: buildI18nRenderContext(i18nConfig, locale, currentDefaultLocale, domainLocales),
 					isFallback: isFallbackRender,
 					pageProps,
+					props: renderProps,
 					params,
 					renderDocumentToString(element) {
 						return renderToStringAsync(element);

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

@@ -93,6 +93,7 @@ type RenderPagesPageResponseOptions = {
    */
   isFallback?: boolean;
   pageProps: Record<string, unknown>;
+  props?: Record<string, unknown>;
   params: Record<string, unknown>;
   renderDocumentToString: (element: ReactNode) => Promise<string>;
   renderToReadableStream: (element: ReactNode) => Promise<ReadableStream<Uint8Array>>;
@@ -127,7 +128,7 @@ type RenderPagesPageResponseOptions = {
    */
   requestCacheControl?: string;
 };
-declare function buildPagesNextDataScript(options: Pick<RenderPagesPageResponseOptions, "buildId" | "i18n" | "isFallback" | "pageProps" | "params" | "routePattern" | "safeJsonStringify" | "scriptNonce" | "nextData"> & {
+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>;

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

@@ -5,6 +5,7 @@ import { fnv1a52 } from "../utils/hash.js";
 import { encodeCacheTag } from "../utils/encode-cache-tag.js";
 import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders } from "./cache-control.js";
 import { buildMissIsrCacheControl } from "./isr-decision.js";
+import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr } from "./html.js";
 import { getClientTraceMetadataHTML } from "./client-trace-metadata.js";
@@ -62,14 +63,14 @@ function requestsNoCache(cacheControl) {
 function buildPagesFontHeadHtml(fontLinks, fontPreloads, fontStyles, scriptNonce) {
 	let html = "";
 	const nonceAttr = createNonceAttribute(scriptNonce);
-	for (const link of fontLinks) html += `<link rel="stylesheet"${nonceAttr} href="${escapeHtmlAttr(link)}" />\n  `;
-	for (const preload of fontPreloads) html += `<link rel="preload"${nonceAttr} href="${escapeHtmlAttr(preload.href)}" as="font" type="${escapeHtmlAttr(preload.type)}" crossorigin />\n  `;
+	for (const link of fontLinks) html += `<link rel="stylesheet"${nonceAttr} href="${escapeHtmlAttr(appendAssetDeploymentIdQuery(link))}" />\n  `;
+	for (const preload of fontPreloads) html += `<link rel="preload"${nonceAttr} href="${escapeHtmlAttr(appendAssetDeploymentIdQuery(preload.href))}" as="font" type="${escapeHtmlAttr(preload.type)}" crossorigin />\n  `;
 	if (fontStyles.length > 0) html += `<style data-vinext-fonts${nonceAttr}>${fontStyles.join("\n")}</style>\n  `;
 	return html;
 }
 function buildPagesNextDataScript(options) {
 	const nextDataPayload = {
-		props: { pageProps: options.pageProps },
+		props: options.props ?? { pageProps: options.pageProps },
 		page: options.routePattern,
 		query: options.params,
 		buildId: options.buildId,
@@ -171,6 +172,7 @@ function applyGsspHeaders(headers, gsspRes, statusCode) {
 	return statusCode ?? gsspRes.statusCode;
 }
 async function renderPagesPageResponse(options) {
+	const renderProps = options.props ?? { pageProps: options.pageProps };
 	options.resetSSRHead?.();
 	await options.flushPreloads?.();
 	const fontHeadHTML = buildPagesFontHeadHtml(options.getFontLinks(), options.fontPreloads, options.getFontStyles(), options.scriptNonce);
@@ -179,6 +181,7 @@ async function renderPagesPageResponse(options) {
 		i18n: options.i18n,
 		isFallback: options.isFallback,
 		pageProps: options.pageProps,
+		props: renderProps,
 		params: options.params,
 		routePattern: options.routePattern,
 		safeJsonStringify: options.safeJsonStringify,
@@ -205,7 +208,7 @@ async function renderPagesPageResponse(options) {
 		controller.close();
 	} });
 	else {
-		const pageElement = withScriptNonce(React.createElement(React.Fragment, null, options.createPageElement(options.pageProps)), options.scriptNonce);
+		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);

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

@@ -5,6 +5,7 @@ import { HeaderRecord } from "./request-pipeline.js";
 type PagesRenderOptions = {
   isDataReq?: boolean;
   renderErrorPageOnMiss?: boolean;
+  originalUrl?: string;
 };
 type MiddlewareResult = {
   continue: boolean;

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

@@ -1,6 +1,6 @@
 import { addBasePathToPathname, hasBasePath } from "../utils/base-path.js";
 import { applyMiddlewareRequestHeaders, isExternalUrl, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
-import { applyConfigHeadersToHeaderRecord, normalizeTrailingSlash } from "./request-pipeline.js";
+import { applyConfigHeadersToHeaderRecord, cloneRequestWithUrl, normalizeTrailingSlash } from "./request-pipeline.js";
 import { mergeRewriteQuery } from "../utils/query.js";
 import { normalizeDefaultLocalePathname, stripI18nLocaleForApiRoute } from "./pages-i18n.js";
 import { mergeHeaders } from "./worker-utils.js";
@@ -68,7 +68,8 @@ async function runPagesRequest(request, deps) {
 			};
 		}
 	}
-	let resolvedUrl = pathname + search;
+	const originalResolvedUrl = pathname + search;
+	let resolvedUrl = originalResolvedUrl;
 	const middlewareHeaders = {};
 	let middlewareStatus;
 	if (typeof deps.runMiddleware === "function") {
@@ -114,7 +115,12 @@ async function runPagesRequest(request, deps) {
 	}
 	const { postMwReqCtx, request: postMwReq } = applyMiddlewareRequestHeaders(middlewareHeaders, request, { preserveCredentialHeaders: isExternalUrl(resolvedUrl) });
 	request = postMwReq;
-	let resolvedPathname = resolvedUrl.split("?")[0];
+	const pathnameForResolvedUrl = (value) => value.split("#", 1)[0].split("?", 1)[0];
+	const rewriteRequestContext = () => ({
+		...postMwReqCtx,
+		query: new URL(resolvedUrl, url).searchParams
+	});
+	let resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
 	const matchResolvedPathname = (p) => i18nConfig ? normalizeDefaultLocalePathname(p, i18nConfig, { hostname: requestHostname }) : p;
 	if (configHeaders.length) applyConfigHeadersToHeaderRecord(middlewareHeaders, {
 		configHeaders,
@@ -130,15 +136,15 @@ async function runPagesRequest(request, deps) {
 		if (await deps.serveStaticFile(pathname, middlewareHeaders)) return { type: "handled" };
 	}
 	let configRewriteFired = false;
-	if (configRewrites.beforeFiles?.length) {
-		const rewritten = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.beforeFiles, postMwReqCtx, basePathState);
+	for (const rewrite of configRewrites.beforeFiles ?? []) {
+		const rewritten = matchRewrite(matchResolvedPathname(resolvedPathname), [rewrite], rewriteRequestContext(), basePathState);
 		if (rewritten) {
 			if (isExternalUrl(rewritten)) return {
 				type: "response",
 				response: await proxyExternal(request, rewritten)
 			};
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
-			resolvedPathname = resolvedUrl.split("?")[0];
+			resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
 			configRewriteFired = true;
 		}
 	}
@@ -151,34 +157,61 @@ async function runPagesRequest(request, deps) {
 	};
 	const apiLookupUrl = stripI18nLocaleForApiRoute(resolvedUrl, i18nConfig);
 	const apiLookupPathname = apiLookupUrl.split("?")[0];
-	if (apiLookupPathname.startsWith("/api/") || apiLookupPathname === "/api") if (typeof deps.handleApi === "function") return {
-		type: "response",
-		defaultContentType: "application/octet-stream",
-		response: mergeHeaders(await deps.handleApi(request, apiLookupUrl, deps.ctx ?? null), middlewareHeaders, middlewareStatus)
-	};
-	else return {
+	if (apiLookupPathname.startsWith("/api/") || apiLookupPathname === "/api") if (typeof deps.handleApi === "function") {
+		let apiRequest = request;
+		if (basePath && hadBasePath) {
+			const apiRequestUrl = new URL(request.url);
+			apiRequestUrl.pathname = addBasePathToPathname(apiRequestUrl.pathname, basePath);
+			apiRequest = cloneRequestWithUrl(request, apiRequestUrl.toString());
+		}
+		return {
+			type: "response",
+			defaultContentType: "application/octet-stream",
+			response: mergeHeaders(await deps.handleApi(apiRequest, apiLookupUrl, deps.ctx ?? null), middlewareHeaders, middlewareStatus)
+		};
+	} else return {
 		type: "api",
 		apiUrl: apiLookupUrl,
 		stagedHeaders: middlewareHeaders,
 		requestHeaders: request.headers,
 		middlewareStatus
 	};
-	const pageMatch = deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
+	let pageMatch = deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
 	let resolvedPathnameChanged = false;
-	if ((!pageMatch || pageMatch.route.isDynamic) && configRewrites.afterFiles?.length) {
-		const rewritten = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.afterFiles, postMwReqCtx, basePathState);
+	if (!pageMatch || pageMatch.route.isDynamic) for (const rewrite of configRewrites.afterFiles ?? []) {
+		const rewritten = matchRewrite(matchResolvedPathname(resolvedPathname), [rewrite], rewriteRequestContext(), basePathState);
 		if (rewritten) {
 			if (isExternalUrl(rewritten)) return {
 				type: "response",
 				response: await proxyExternal(request, rewritten)
 			};
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
-			resolvedPathname = resolvedUrl.split("?")[0];
+			resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
 			resolvedPathnameChanged = true;
+			pageMatch = deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
+			if (pageMatch) break;
 		}
 	}
+	const refreshDataRewriteHeader = () => {
+		if ((isDataReq || isDataRequest) && resolvedUrl !== originalResolvedUrl && !isExternalUrl(resolvedUrl)) middlewareHeaders["x-nextjs-rewrite"] = resolvedUrl;
+		else delete middlewareHeaders["x-nextjs-rewrite"];
+	};
+	refreshDataRewriteHeader();
 	if (typeof deps.renderPage === "function") {
-		const renderPageMatch = resolvedPathnameChanged ? deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null : pageMatch;
+		let renderPageMatch = pageMatch;
+		if ((isDataReq || isDataRequest) && !renderPageMatch && configRewrites.fallback?.length) for (const rewrite of configRewrites.fallback) {
+			const fallbackRewrite = matchRewrite(matchResolvedPathname(resolvedPathname), [rewrite], rewriteRequestContext(), basePathState);
+			if (!fallbackRewrite) continue;
+			if (isExternalUrl(fallbackRewrite)) return {
+				type: "response",
+				response: await proxyExternal(request, fallbackRewrite)
+			};
+			resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
+			resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
+			renderPageMatch = deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null;
+			refreshDataRewriteHeader();
+			if (renderPageMatch) break;
+		}
 		const shouldDeferErrorPageOnMiss = !isDataReq && !isDataRequest && !!deps.matchPageRoute && !renderPageMatch;
 		const initialRenderOptions = shouldDeferErrorPageOnMiss ? { renderErrorPageOnMiss: false } : isDataReq ? { isDataReq: true } : void 0;
 		const stagedHeaders = new Headers();
@@ -186,16 +219,18 @@ async function runPagesRequest(request, deps) {
 		else stagedHeaders.set(k, v);
 		let response = await deps.renderPage(request, resolvedUrl, initialRenderOptions, stagedHeaders);
 		let matchedFallbackRewrite = false;
-		if (response.status === 404 && shouldDeferErrorPageOnMiss && configRewrites.fallback?.length) {
-			const fallbackRewrite = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.fallback, postMwReqCtx, basePathState);
-			if (fallbackRewrite) {
-				if (isExternalUrl(fallbackRewrite)) return {
-					type: "response",
-					response: await proxyExternal(request, fallbackRewrite)
-				};
-				response = await deps.renderPage(request, mergeRewriteQuery(resolvedUrl, fallbackRewrite), void 0, stagedHeaders);
-				matchedFallbackRewrite = true;
-			}
+		if (response.status === 404 && shouldDeferErrorPageOnMiss && configRewrites.fallback?.length) for (const rewrite of configRewrites.fallback) {
+			const fallbackRewrite = matchRewrite(matchResolvedPathname(resolvedPathname), [rewrite], rewriteRequestContext(), basePathState);
+			if (!fallbackRewrite) continue;
+			if (isExternalUrl(fallbackRewrite)) return {
+				type: "response",
+				response: await proxyExternal(request, fallbackRewrite)
+			};
+			resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
+			resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
+			response = await deps.renderPage(request, resolvedUrl, void 0, stagedHeaders);
+			matchedFallbackRewrite = true;
+			if (response.status !== 404) break;
 		}
 		if (response.status === 404 && shouldDeferErrorPageOnMiss && !matchedFallbackRewrite) response = await deps.renderPage(request, resolvedUrl, void 0, stagedHeaders);
 		const merged = mergeHeaders(response, middlewareHeaders, middlewareStatus);
@@ -206,16 +241,18 @@ async function runPagesRequest(request, deps) {
 			defaultContentType: "text/html"
 		};
 	}
-	if (!(resolvedPathnameChanged ? deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null : pageMatch) && configRewrites.fallback?.length) {
-		const fallbackRewrite = matchRewrite(matchResolvedPathname(resolvedPathname), configRewrites.fallback, postMwReqCtx, basePathState);
-		if (fallbackRewrite) {
-			if (isExternalUrl(fallbackRewrite)) return {
-				type: "response",
-				response: await proxyExternal(request, fallbackRewrite)
-			};
-			resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
-		}
+	if (!(resolvedPathnameChanged ? deps.matchPageRoute ? deps.matchPageRoute(resolvedPathname, request) : null : pageMatch) && configRewrites.fallback?.length) for (const rewrite of configRewrites.fallback) {
+		const fallbackRewrite = matchRewrite(matchResolvedPathname(resolvedPathname), [rewrite], rewriteRequestContext(), basePathState);
+		if (!fallbackRewrite) continue;
+		if (isExternalUrl(fallbackRewrite)) return {
+			type: "response",
+			response: await proxyExternal(request, fallbackRewrite)
+		};
+		resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
+		resolvedPathname = pathnameForResolvedUrl(resolvedUrl);
+		if (deps.matchPageRoute?.(resolvedPathname, request)) break;
 	}
+	refreshDataRewriteHeader();
 	return {
 		type: "render",
 		resolvedUrl,

package/dist/server/pregenerated-concrete-paths.d.ts

@@ -4,28 +4,12 @@ declare global {
 }
 declare function normalizePregeneratedPathname(pathname: string): string;
 declare function clearPregeneratedConcretePaths(): void;
-/**
- * Records a concrete URL path for a route pattern. The pathname is normalized
- * here so this is the single source of truth: every caller — the Worker global
- * table and the Node `seed-cache.ts` path — stores the canonical form that
- * matches the runtime `cleanPathname` lookup without having to pre-normalize.
- */
 declare function addPregeneratedConcretePath(routePattern: string, pathname: string): void;
-/**
- * Returns the live backing `Set` for a route pattern (not a copy) to keep
- * lookups allocation-free on the serving hot path. The `ReadonlySet` type
- * forbids mutation at compile time. Callers must treat the result as
- * point-in-time and must NOT retain it across a re-seed: each
- * `initPregeneratedPathsFromGlobals` call runs `clearPregeneratedConcretePaths`,
- * which empties the map, leaving any previously-returned reference stale. Read
- * it, use it, drop it — never cache the reference.
- */
 declare function getRenderedConcreteUrlPathsForRoute(routePattern: string): ReadonlySet<string> | undefined;
 /**
  * Populate the registry from `globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS`.
  * No-op when the global is not set (Node path — seed-cache handles it later).
- * `addPregeneratedConcretePath` normalizes each pathname so it matches the
- * runtime `cleanPathname`.
+ * Pathnames are normalised so they match the runtime `cleanPathname`.
  */
 declare function initPregeneratedPathsFromGlobals(): void;
 //#endregion

package/dist/server/pregenerated-concrete-paths.js

@@ -16,38 +16,21 @@ const concreteUrlPathsByRoute = /* @__PURE__ */ new Map();
 function clearPregeneratedConcretePaths() {
 	concreteUrlPathsByRoute.clear();
 }
-/**
-* Records a concrete URL path for a route pattern. The pathname is normalized
-* here so this is the single source of truth: every caller — the Worker global
-* table and the Node `seed-cache.ts` path — stores the canonical form that
-* matches the runtime `cleanPathname` lookup without having to pre-normalize.
-*/
 function addPregeneratedConcretePath(routePattern, pathname) {
-	const normalized = normalizePregeneratedPathname(pathname);
 	let paths = concreteUrlPathsByRoute.get(routePattern);
 	if (!paths) {
 		paths = /* @__PURE__ */ new Set();
 		concreteUrlPathsByRoute.set(routePattern, paths);
 	}
-	paths.add(normalized);
+	paths.add(normalizePregeneratedPathname(pathname));
 }
-/**
-* Returns the live backing `Set` for a route pattern (not a copy) to keep
-* lookups allocation-free on the serving hot path. The `ReadonlySet` type
-* forbids mutation at compile time. Callers must treat the result as
-* point-in-time and must NOT retain it across a re-seed: each
-* `initPregeneratedPathsFromGlobals` call runs `clearPregeneratedConcretePaths`,
-* which empties the map, leaving any previously-returned reference stale. Read
-* it, use it, drop it — never cache the reference.
-*/
 function getRenderedConcreteUrlPathsForRoute(routePattern) {
 	return concreteUrlPathsByRoute.get(routePattern);
 }
 /**
 * Populate the registry from `globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS`.
 * No-op when the global is not set (Node path — seed-cache handles it later).
-* `addPregeneratedConcretePath` normalizes each pathname so it matches the
-* runtime `cleanPathname`.
+* Pathnames are normalised so they match the runtime `cleanPathname`.
 */
 function initPregeneratedPathsFromGlobals() {
 	const raw = globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS;

package/dist/server/prerender-manifest.d.ts

@@ -0,0 +1,33 @@
+//#region src/server/prerender-manifest.d.ts
+type PrerenderManifestRoute = {
+  route: string;
+  status?: string;
+  revalidate?: number | false;
+  expire?: number;
+  path?: string;
+  router?: string;
+  fallback?: boolean;
+};
+type PrerenderManifest = {
+  buildId?: string;
+  trailingSlash?: boolean;
+  routes?: PrerenderManifestRoute[];
+};
+declare function readPrerenderManifest(manifestPath: string): PrerenderManifest | null;
+declare function getRenderedAppRoutes(routes: PrerenderManifestRoute[]): PrerenderManifestRoute[];
+/**
+ * Returns true when `pathname` contains bracket-delimited route params,
+ * indicating it is a fallback-shell placeholder (e.g. `/en/blog/[slug]`)
+ * rather than a concrete rendered URL.
+ */
+declare function isFallbackShellArtifactPath(pathname: string, route?: PrerenderManifestRoute): boolean;
+/**
+ * Build the pregenerated concrete-path payload table from a prerender manifest.
+ *
+ * Filters out fallback-shell placeholder paths and groups remaining concrete
+ * paths by route pattern. Returns an empty array when the manifest has no
+ * rendered App routes or all routes are fallback-shell artifacts.
+ */
+declare function buildPregeneratedConcretePathTable(manifest: PrerenderManifest): Array<[string, string[]]>;
+//#endregion
+export { buildPregeneratedConcretePathTable, getRenderedAppRoutes, isFallbackShellArtifactPath, readPrerenderManifest };

package/dist/server/prerender-manifest.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+//#region src/server/prerender-manifest.ts
+function readPrerenderManifest(manifestPath) {
+	if (!fs.existsSync(manifestPath)) return null;
+	try {
+		return JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+	} catch (error) {
+		console.warn(`[vinext] Failed to read prerender manifest at ${manifestPath}:`, error);
+		return null;
+	}
+}
+function getRenderedAppRoutes(routes) {
+	return routes.filter((r) => r.status === "rendered" && r.router === "app");
+}
+function groupRoutesByPattern(routes) {
+	const byPattern = /* @__PURE__ */ new Map();
+	for (const r of routes) {
+		const pathname = r.path ?? r.route;
+		const existing = byPattern.get(r.route);
+		if (existing) existing.push(pathname);
+		else byPattern.set(r.route, [pathname]);
+	}
+	return byPattern;
+}
+/**
+* Returns true when `pathname` contains bracket-delimited route params,
+* indicating it is a fallback-shell placeholder (e.g. `/en/blog/[slug]`)
+* rather than a concrete rendered URL.
+*/
+function isFallbackShellArtifactPath(pathname, route) {
+	if (route?.fallback === true) return true;
+	if (route?.fallback === void 0) {
+		if (process.env.NODE_ENV !== "production") console.warn("[vinext] Legacy manifest detected: missing `fallback` flag for route. Using bracket heuristic for fallback-shell detection. A concrete URL containing literal brackets may be misclassified as a fallback shell.");
+		return pathname.includes("[") || pathname.includes("]");
+	}
+	return false;
+}
+/**
+* Build the pregenerated concrete-path payload table from a prerender manifest.
+*
+* Filters out fallback-shell placeholder paths and groups remaining concrete
+* paths by route pattern. Returns an empty array when the manifest has no
+* rendered App routes or all routes are fallback-shell artifacts.
+*/
+function buildPregeneratedConcretePathTable(manifest) {
+	const routes = manifest?.routes;
+	if (!routes?.length) return [];
+	const concreteRoutes = getRenderedAppRoutes(routes).filter((r) => {
+		return !isFallbackShellArtifactPath(r.path ?? r.route, r);
+	});
+	return Array.from(groupRoutesByPattern(concreteRoutes).entries());
+}
+//#endregion
+export { buildPregeneratedConcretePathTable, getRenderedAppRoutes, isFallbackShellArtifactPath, readPrerenderManifest };

package/dist/server/prerender-route-params.d.ts

@@ -5,7 +5,6 @@ type PrerenderRouteParamsPayload = {
   params: PrerenderRouteParams;
   routePattern: string;
 };
-/** @public exported for #1716 serving consumers; not yet referenced in-repo */
 type PrerenderRouteParamsRouteMatch = {
   kind: "exact";
   params: PrerenderRouteParams;
@@ -21,4 +20,4 @@ declare function prerenderRouteParamsPayloadMatchesRoute(payload: PrerenderRoute
 declare function matchPrerenderRouteParamsPayload(payload: PrerenderRouteParamsPayload | null, routePattern: string, params: PrerenderRouteParams): PrerenderRouteParamsRouteMatch | null;
 declare function encodePrerenderRouteParams(pattern: string, params: PrerenderRouteParams, fallbackParamNames?: readonly string[]): PrerenderRouteParamsPayload | null;
 //#endregion
-export { PrerenderRouteParams, PrerenderRouteParamsPayload, PrerenderRouteParamsRouteMatch, encodePrerenderRouteParams, matchPrerenderRouteParamsPayload, prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader };
+export { PrerenderRouteParams, PrerenderRouteParamsPayload, encodePrerenderRouteParams, matchPrerenderRouteParamsPayload, prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader };