vinext 0.1.2 → 0.1.4

package/dist/server/app-rsc-handler.d.ts

@@ -1,4 +1,5 @@
 import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config/next-config.js";
+import { ImageConfig } from "./image-optimization.js";
 import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { RootParams } from "../shims/root-params.js";
 import { MiddlewareModule } from "./middleware-runtime.js";
@@ -17,6 +18,7 @@ type RootParamNamesMap = Parameters<typeof handleAppPrerenderEndpoint>[1]["rootP
 type AppRscMiddlewareContext = AppMiddlewareContext;
 type AppRscHandlerRoute = {
   isDynamic: boolean;
+  params?: readonly string[];
   page?: unknown;
   pattern: string;
   rootParamNames?: readonly string[];
@@ -41,6 +43,17 @@ type DispatchMatchedPageOptions<TRoute> = {
   middlewareContext: AppRscMiddlewareContext;
   mountedSlotsHeader: string | null;
   params: AppPageParams;
+  pprFallbackCacheShells?: readonly {
+    fallbackParamNames: readonly string[];
+    params: AppPageParams;
+    pathname: string;
+  }[] | null;
+  pprFallbackShell?: {
+    fallbackParamNames: readonly string[];
+    routePattern: string;
+  };
+  renderedConcreteUrlPaths?: ReadonlySet<string>;
+  skipStaticParamsValidation?: boolean;
   staticParamsValidationParams?: AppPageParams;
   rootParams?: RootParams;
   request: Request;
@@ -110,8 +123,19 @@ type RenderNotFoundOptions<TRoute> = {
   scriptNonce?: string;
 };
 type RenderPagesFallbackOptions = {
+  allowRscDocumentFallback?: boolean;
+  appRouteMatch?: {
+    route: {
+      isDynamic: boolean;
+      pattern: string;
+    };
+  } | null;
+  isDataRequest?: boolean;
   isRscRequest: boolean;
+  matchKind?: "dynamic" | "static";
   middlewareContext: AppRscMiddlewareContext;
+  pathname?: string;
+  pagesDataRequest?: Request | null;
   request: Request;
   url: URL;
 };
@@ -122,6 +146,8 @@ type NavigationContextValue = {
 };
 type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   basePath: string;
+  buildId: string | null;
+  cacheComponents?: boolean;
   clearRequestContext: () => void;
   configHeaders: NextHeader[];
   configRedirects: NextRedirect[];
@@ -150,6 +176,8 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   handleProgressiveActionRequest: (options: HandleProgressiveActionRequestOptions) => Promise<Response | ProgressiveActionFormStateResult | null>;
   handleServerActionRequest: (options: HandleServerActionRequestOptions) => Promise<Response | null>;
   i18nConfig: NextI18nConfig | null;
+  imageConfig?: ImageConfig;
+  isDev: boolean;
   isMiddlewareProxy: boolean;
   loadPrerenderPagesRoutes?: () => Promise<unknown>;
   makeThenableParams: MakeThenableParams;

package/dist/server/app-rsc-handler.js

@@ -1,30 +1,35 @@
 import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
-import { hasBasePath } from "../utils/base-path.js";
+import { addBasePathToPathname, hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { ACTION_REVALIDATED_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
 import { isExternalUrl, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
 import { notFoundResponse } from "./http-error-responses.js";
-import { applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute, validateImageUrl } from "./request-pipeline.js";
+import { applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute } from "./request-pipeline.js";
 import { headersContextFromRequest } from "../shims/headers.js";
 import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
-import { createRscRedirectLocation, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
+import { mergeRewriteQuery } from "../utils/query.js";
+import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, createRscRedirectLocation, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
-import { isImageOptimizationPath } from "./image-optimization.js";
+import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath, resolveDevImageRedirect } from "./image-optimization.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import "./app-page-response.js";
-import { prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
+import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
+import { createAppPprFallbackShells } from "./app-ppr-fallback-shell.js";
+import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
+import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
+import { pickRootParams, setRootParams } from "../shims/root-params.js";
+import { flattenErrorCauses } from "../utils/error-cause.js";
 import { applyAppMiddleware } from "./app-middleware.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
-import { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { handleAppPrerenderEndpoint } from "./app-prerender-endpoints.js";
-import { flattenErrorCauses } from "../utils/error-cause.js";
 import { finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
 import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
 import { handleMetadataRouteRequest } from "./metadata-route-response.js";
 import { runWithPrerenderWorkUnit } from "./prerender-work-unit-setup.js";
 //#region src/server/app-rsc-handler.ts
+const STATIC_METADATA_CONFIG_HEADER_OVERRIDES = new Set(["cache-control"]);
 function applyMiddlewareContextToResponse(response, middlewareContext) {
 	if (!middlewareContext.headers && middlewareContext.status == null) return response;
 	const headers = new Headers(response.headers);
@@ -38,6 +43,10 @@ function applyMiddlewareContextToResponse(response, middlewareContext) {
 function hasProperty(value, key) {
 	return key in value;
 }
+function isEdgeRouteHandler(handler) {
+	if (!handler || typeof handler !== "object" || !hasProperty(handler, "runtime")) return false;
+	return handler.runtime === "edge" || handler.runtime === "experimental-edge";
+}
 function isExecutionContextLike(value) {
 	if (!value || typeof value !== "object") return false;
 	return hasProperty(value, "waitUntil") && typeof value.waitUntil === "function";
@@ -56,6 +65,17 @@ async function applyRewrite(options, cleanPathname) {
 	}
 	return rewritten;
 }
+function requestContextForResolvedUrl(requestContext, resolvedUrl, baseUrl) {
+	return {
+		cookies: requestContext.cookies,
+		headers: requestContext.headers,
+		host: requestContext.host,
+		query: new URL(resolvedUrl, baseUrl).searchParams
+	};
+}
+function pathnameForResolvedUrl(resolvedUrl) {
+	return resolvedUrl.split("#", 1)[0].split("?", 1)[0];
+}
 function applyConfigHeadersToMiddlewareRedirect(response, options) {
 	if (response.status < 300 || response.status >= 400) return response;
 	if (!options.configHeaders.length) return response;
@@ -82,7 +102,14 @@ function requestWithoutRscCacheBustingSearchParam(request) {
 	stripRscCacheBustingSearchParam(url);
 	return cloneRequestWithUrl(request.body ? request.clone() : request, url.toString());
 }
-async function handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest) {
+function requestWithoutRscSuffix(request) {
+	const url = new URL(request.url);
+	const pathname = stripRscSuffix(url.pathname);
+	if (pathname === url.pathname) return request;
+	url.pathname = pathname;
+	return cloneRequestWithUrl(request.body ? request.clone() : request, url.toString());
+}
+async function handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, pagesDataRequest) {
 	const handlerStart = process.env.NODE_ENV !== "production" ? performance.now() : 0;
 	if (process.env.NODE_ENV !== "production") {
 		const originBlock = options.validateDevRequestOrigin?.(request);
@@ -92,6 +119,9 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	if (normalized instanceof Response) return normalized;
 	const { url, isRscRequest, interceptionContextHeader, mountedSlotsHeader, renderMode, clientReuseManifest } = normalized;
 	let { pathname, cleanPathname } = normalized;
+	let resolvedUrl = cleanPathname + url.search;
+	const originalResolvedUrl = resolvedUrl;
+	const getResolvedSearchParams = () => new URL(resolvedUrl, url).searchParams;
 	const canonicalPathname = cleanPathname;
 	const basePathState = {
 		basePath: options.basePath,
@@ -114,6 +144,10 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	if (redirect) {
 		const destination = sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath));
 		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : preserveRedirectDestinationQuery(destination, url.search);
+		if (isDataRequest) return new Response(null, {
+			status: 200,
+			headers: { "x-nextjs-redirect": location }
+		});
 		return new Response(null, {
 			status: redirect.permanent ? 308 : 307,
 			headers: { Location: location }
@@ -124,12 +158,14 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		request
 	});
 	if (rscCacheBustingRedirect) return rscCacheBustingRedirect;
-	const userlandRequest = isRscRequest ? requestWithoutRscCacheBustingSearchParam(request) : request;
+	const normalizedUserlandRequest = requestWithoutRscSuffix(request);
+	const userlandRequest = requestWithoutRscCacheBustingSearchParam(normalizedUserlandRequest);
 	const middlewareContext = {
 		headers: null,
 		requestHeaders: null,
 		status: null
 	};
+	let didMiddlewareRewrite = false;
 	if (options.middlewareModule) {
 		const middlewareResult = await applyAppMiddleware({
 			basePath: options.basePath,
@@ -149,30 +185,46 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			requestContext: preMiddlewareRequestContext
 		});
 		cleanPathname = middlewareResult.cleanPathname;
+		didMiddlewareRewrite = cleanPathname !== normalized.cleanPathname;
 		if (middlewareResult.search !== null) url.search = middlewareResult.search;
+		resolvedUrl = cleanPathname + url.search;
 	}
 	const scriptNonce = getScriptNonceFromHeaderSources(request.headers, middlewareContext.headers);
 	const postMiddlewareRequestContext = buildPostMwRequestContext(userlandRequest);
-	const beforeFilesRewrite = await applyRewrite({
-		basePathState,
-		clearRequestContext: options.clearRequestContext,
-		request: userlandRequest,
-		requestContext: postMiddlewareRequestContext,
-		rewrites: options.configRewrites.beforeFiles
-	}, matchPathname(cleanPathname));
-	if (beforeFilesRewrite instanceof Response) return beforeFilesRewrite;
-	if (beforeFilesRewrite) cleanPathname = beforeFilesRewrite;
+	for (const rewrite of options.configRewrites.beforeFiles) {
+		const beforeFilesRewrite = await applyRewrite({
+			basePathState,
+			clearRequestContext: options.clearRequestContext,
+			request: normalizedUserlandRequest,
+			requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+			rewrites: [rewrite]
+		}, matchPathname(cleanPathname));
+		if (beforeFilesRewrite instanceof Response) return beforeFilesRewrite;
+		if (beforeFilesRewrite) {
+			resolvedUrl = mergeRewriteQuery(resolvedUrl, beforeFilesRewrite);
+			cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		}
+	}
 	if (isImageOptimizationPath(cleanPathname)) {
-		const imageUrlResult = validateImageUrl(url.searchParams.get("url"), request.url);
-		if (imageUrlResult instanceof Response) return imageUrlResult;
-		return Response.redirect(new URL(imageUrlResult, url.origin).href, 302);
+		const imageRedirect = resolveDevImageRedirect(url, [...options.imageConfig?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...options.imageConfig?.imageSizes ?? DEFAULT_IMAGE_SIZES], options.imageConfig?.qualities, { isDev: options.isDev });
+		if (!imageRedirect) return new Response("Invalid image optimization parameters", { status: 400 });
+		return Response.redirect(new URL(imageRedirect, url.origin).href, 302);
 	}
 	const metadataRouteResponse = await handleMetadataRouteRequest({
 		metadataRoutes: options.metadataRoutes,
 		cleanPathname,
 		makeThenableParams: options.makeThenableParams
 	});
-	if (metadataRouteResponse) return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
+	if (metadataRouteResponse) {
+		applyConfigHeadersToResponse(metadataRouteResponse.headers, {
+			basePathState,
+			configHeaders: options.configHeaders,
+			overwriteExisting: STATIC_METADATA_CONFIG_HEADER_OVERRIDES,
+			pathname: matchPathname(cleanPathname),
+			requestContext: preMiddlewareRequestContext
+		});
+		return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
+	}
 	const publicFileResponse = resolvePublicFileRoute({
 		cleanPathname,
 		middlewareContext,
@@ -184,10 +236,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		options.clearRequestContext();
 		return publicFileResponse;
 	}
-	if (isRscRequest) stripRscCacheBustingSearchParam(url);
+	stripRscCacheBustingSearchParam(url);
+	const resolved = new URL(resolvedUrl, url);
+	stripRscCacheBustingSearchParam(resolved);
+	resolvedUrl = resolved.pathname + resolved.search + resolved.hash;
 	options.setNavigationContext({
 		pathname: canonicalPathname,
-		searchParams: url.searchParams,
+		searchParams: getResolvedSearchParams(),
 		params: {}
 	});
 	const preActionMatch = options.matchRoute(cleanPathname);
@@ -216,53 +271,101 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		middlewareContext,
 		mountedSlotsHeader,
 		request,
-		searchParams: url.searchParams
+		searchParams: getResolvedSearchParams()
 	});
 	if (serverActionResponse) return serverActionResponse;
 	let match = preActionMatch;
-	if (!match || match.route.isDynamic) {
+	const renderPagesForMatchKind = async (matchKind) => {
+		const response = match === null || match.route.isDynamic ? await options.renderPagesFallback?.({
+			appRouteMatch: match ?? null,
+			allowRscDocumentFallback: didMiddlewareRewrite,
+			isDataRequest,
+			isRscRequest,
+			matchKind,
+			middlewareContext,
+			pathname: resolvedUrl,
+			pagesDataRequest,
+			request,
+			url
+		}) ?? null : null;
+		if (!response || !pagesDataRequest || resolvedUrl === originalResolvedUrl) return response;
+		const headers = new Headers(response.headers);
+		headers.set("x-nextjs-rewrite", resolvedUrl);
+		return new Response(response.body, {
+			headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+	};
+	const staticPagesFallbackResponse = await renderPagesForMatchKind("static");
+	if (staticPagesFallbackResponse) {
+		options.clearRequestContext();
+		return staticPagesFallbackResponse;
+	}
+	if (!match || match.route.isDynamic) for (const rewrite of options.configRewrites.afterFiles) {
 		const afterFilesRewrite = await applyRewrite({
 			basePathState,
 			clearRequestContext: options.clearRequestContext,
-			request: userlandRequest,
-			requestContext: postMiddlewareRequestContext,
-			rewrites: options.configRewrites.afterFiles
+			request: normalizedUserlandRequest,
+			requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+			rewrites: [rewrite]
 		}, matchPathname(cleanPathname));
 		if (afterFilesRewrite instanceof Response) return afterFilesRewrite;
-		if (afterFilesRewrite) {
-			cleanPathname = afterFilesRewrite;
-			match = options.matchRoute(cleanPathname);
+		if (!afterFilesRewrite) continue;
+		resolvedUrl = mergeRewriteQuery(resolvedUrl, afterFilesRewrite);
+		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		match = options.matchRoute(cleanPathname);
+		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
+		if (rewrittenStaticPagesResponse) {
+			options.clearRequestContext();
+			return rewrittenStaticPagesResponse;
+		}
+		const rewrittenDynamicPagesResponse = await renderPagesForMatchKind("dynamic");
+		if (rewrittenDynamicPagesResponse) {
+			options.clearRequestContext();
+			return rewrittenDynamicPagesResponse;
 		}
+		if (match) break;
 	}
-	if (!match) {
+	const dynamicPagesFallbackResponse = await renderPagesForMatchKind("dynamic");
+	if (dynamicPagesFallbackResponse) {
+		options.clearRequestContext();
+		return dynamicPagesFallbackResponse;
+	}
+	if (!match) for (const rewrite of options.configRewrites.fallback) {
 		const fallbackRewrite = await applyRewrite({
 			basePathState,
 			clearRequestContext: options.clearRequestContext,
-			request: userlandRequest,
-			requestContext: postMiddlewareRequestContext,
-			rewrites: options.configRewrites.fallback
+			request: normalizedUserlandRequest,
+			requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+			rewrites: [rewrite]
 		}, matchPathname(cleanPathname));
 		if (fallbackRewrite instanceof Response) return fallbackRewrite;
-		if (fallbackRewrite) {
-			cleanPathname = fallbackRewrite;
-			match = options.matchRoute(cleanPathname);
+		if (!fallbackRewrite) continue;
+		resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
+		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		match = options.matchRoute(cleanPathname);
+		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
+		if (rewrittenStaticPagesResponse) {
+			options.clearRequestContext();
+			return rewrittenStaticPagesResponse;
+		}
+		const rewrittenDynamicPagesResponse = await renderPagesForMatchKind("dynamic");
+		if (rewrittenDynamicPagesResponse) {
+			options.clearRequestContext();
+			return rewrittenDynamicPagesResponse;
 		}
+		if (match) break;
+	}
+	if (pagesDataRequest) {
+		options.clearRequestContext();
+		return buildNextDataNotFoundResponse();
 	}
 	if (!match) {
 		if (process.env.NODE_ENV !== "production" && canonicalPathname === "/favicon.ico") {
 			options.clearRequestContext();
 			return new Response("", { status: 404 });
 		}
-		const pagesFallbackResponse = await options.renderPagesFallback?.({
-			isRscRequest,
-			middlewareContext,
-			request,
-			url
-		});
-		if (pagesFallbackResponse) {
-			options.clearRequestContext();
-			return pagesFallbackResponse;
-		}
 		const renderedNotFoundResponse = await options.renderNotFound({
 			isRscRequest,
 			middlewareContext,
@@ -278,25 +381,37 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	}
 	const { route, params } = match;
 	if (options.ensureRouteLoaded) await options.ensureRouteLoaded(route);
-	const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(request);
-	const prerenderRouteParams = prerenderRouteParamsPayloadMatchesRoute(prerenderRouteParamsPayload, route.pattern, params) ? prerenderRouteParamsPayload.params : null;
+	const prerenderRouteParamsMatch = matchPrerenderRouteParamsPayload(readTrustedPrerenderRouteParams(request), route.pattern, params);
+	const prerenderRouteParams = prerenderRouteParamsMatch?.params ?? null;
+	const isPrerenderFallbackShell = prerenderRouteParamsMatch?.kind === "fallback-shell";
 	const renderParams = prerenderRouteParams ?? params;
+	const resolvedSearchParams = getResolvedSearchParams();
+	const runtimeFallbackShells = options.cacheComponents === true && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params ? createAppPprFallbackShells({
+		params: route.params,
+		pattern: route.pattern,
+		rootParamNames: route.rootParamNames
+	}, params) : [];
 	options.setNavigationContext({
 		pathname: canonicalPathname,
-		searchParams: url.searchParams,
+		searchParams: resolvedSearchParams,
 		params: renderParams
 	});
 	const rootParams = pickRootParams(renderParams, route.rootParamNames);
 	setRootParams(rootParams);
 	if (route.routeHandler) {
 		setCurrentFetchSoftTags(buildPageCacheTags(cleanPathname, [], [...route.routeSegments], "route"));
+		const routeHandlerRequest = isEdgeRouteHandler(route.routeHandler) ? userlandRequest : normalizedUserlandRequest;
+		const routeHandlerUrl = new URL(routeHandlerRequest.url);
+		const internalRscValues = isEdgeRouteHandler(route.routeHandler) ? [] : routeHandlerUrl.searchParams.getAll(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM);
+		routeHandlerUrl.search = resolvedSearchParams.toString();
+		for (const internalRscValue of internalRscValues) routeHandlerUrl.searchParams.append(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, internalRscValue);
 		return options.dispatchMatchedRouteHandler({
 			cleanPathname,
 			middlewareContext,
 			params: route.isDynamic ? renderParams : null,
-			request,
+			request: new Request(routeHandlerUrl, routeHandlerRequest),
 			route,
-			searchParams: url.searchParams
+			searchParams: resolvedSearchParams
 		});
 	}
 	const pageResponse = await options.dispatchMatchedPage({
@@ -313,12 +428,19 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		middlewareContext,
 		mountedSlotsHeader,
 		params: renderParams,
-		staticParamsValidationParams: prerenderRouteParams === null ? void 0 : params,
+		pprFallbackCacheShells: runtimeFallbackShells,
+		pprFallbackShell: isPrerenderFallbackShell ? {
+			fallbackParamNames: prerenderRouteParamsMatch.fallbackParamNames,
+			routePattern: route.pattern
+		} : void 0,
+		renderedConcreteUrlPaths: getRenderedConcreteUrlPathsForRoute(route.pattern),
+		skipStaticParamsValidation: isPrerenderFallbackShell,
+		staticParamsValidationParams: prerenderRouteParams === null || isPrerenderFallbackShell ? void 0 : params,
 		rootParams,
 		request,
 		route,
 		scriptNonce,
-		searchParams: url.searchParams,
+		searchParams: resolvedSearchParams,
 		renderMode
 	});
 	if (isProgressiveActionRender) return applyProgressiveActionSideEffects(pageResponse, progressiveActionResult);
@@ -361,13 +483,27 @@ function createAppRscHandler(options) {
 		options.registerCacheAdapters();
 		await options.ensureInstrumentation?.();
 		const mwCtx = rawRequest.headers.get(VINEXT_MW_CTX_HEADER);
-		const isDataRequest = rawRequest.headers.get("x-nextjs-data") === "1";
+		const hasDataRequestHeader = rawRequest.headers.get("x-nextjs-data") === "1";
+		const pagesDataUrl = new URL(rawRequest.url);
+		const pagesDataInScope = !options.basePath || hasBasePath(pagesDataUrl.pathname, options.basePath);
+		if (pagesDataInScope) pagesDataUrl.pathname = stripBasePath(pagesDataUrl.pathname, options.basePath);
+		const pagesDataCandidate = pagesDataInScope ? cloneRequestWithUrl(rawRequest, pagesDataUrl.toString()) : null;
+		const pagesDataNormalization = options.renderPagesFallback && pagesDataCandidate ? normalizePagesDataRequest(pagesDataCandidate, options.buildId) : null;
+		if (pagesDataNormalization?.notFoundResponse) return pagesDataNormalization.notFoundResponse;
+		const isDataRequest = hasDataRequestHeader || pagesDataNormalization?.isDataReq === true;
 		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(rawRequest);
 		const filteredHeaders = filterInternalHeaders(rawRequest.headers);
 		if (mwCtx !== null) filteredHeaders.set(VINEXT_MW_CTX_HEADER, mwCtx);
 		const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParamsPayload);
 		if (prerenderRouteParamsHeader !== null) filteredHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
-		const request = cloneRequestWithHeaders(rawRequest, filteredHeaders);
+		let appRequest = rawRequest;
+		if (pagesDataNormalization?.isDataReq) {
+			const appRequestUrl = new URL(pagesDataNormalization.request.url);
+			appRequestUrl.pathname = addBasePathToPathname(appRequestUrl.pathname, options.basePath);
+			appRequest = cloneRequestWithUrl(pagesDataCandidate, appRequestUrl.toString());
+		}
+		const request = cloneRequestWithHeaders(appRequest, filteredHeaders);
+		const pagesDataRequest = pagesDataNormalization?.isDataReq ? cloneRequestWithHeaders(pagesDataCandidate, filteredHeaders) : null;
 		const executionContext = isExecutionContextLike(ctx) ? ctx : getRequestExecutionContext() ?? null;
 		return runWithRequestContext(createRequestContext({
 			headersContext: headersContextFromRequest(request, { draftModeSecret: options.draftModeSecret }),
@@ -378,7 +514,7 @@ function createAppRscHandler(options) {
 			const preMiddlewareRequestContext = requestContextFromRequest(request);
 			let response;
 			try {
-				response = await handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest);
+				response = await handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, pagesDataRequest);
 			} catch (error) {
 				if (process.env.NODE_ENV !== "production") flattenErrorCauses(error);
 				throw error;

package/dist/server/app-rsc-route-matching.d.ts

@@ -29,6 +29,7 @@ type AppRscInterceptForMatching = {
    * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/lib/generate-interception-routes-rewrites.ts
    */
   sourceMatchPattern?: string;
+  sourcePageSegments?: readonly string[];
   interceptLayouts: readonly unknown[];
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
@@ -41,6 +42,7 @@ type AppRscSlotForMatching = {
 type AppRscSiblingInterceptForMatching = {
   targetPattern: string;
   sourceMatchPattern: string | null;
+  sourcePageSegments?: readonly string[];
   slotId: string | null;
   interceptLayouts: readonly unknown[];
   page: unknown;
@@ -63,6 +65,7 @@ type AppRscInterceptLookupEntry = {
   targetPatternParts: string[];
   sourceMatchPattern: string | null;
   sourceMatchPatternParts: string[] | null;
+  sourcePageSegments: readonly string[] | null;
   interceptLayouts: readonly unknown[];
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;

package/dist/server/app-rsc-route-matching.js

@@ -18,6 +18,7 @@ function appRscPathnameParts(pathname) {
 function createAppRscRouteMatcher(routes) {
 	const routeTrie = buildRouteTrie(routes);
 	const interceptLookup = createInterceptLookup(routes);
+	const routeIndexes = new Map(routes.map((route, index) => [route, index]));
 	return {
 		matchRoute(url) {
 			return trieMatch(routeTrie, appRscPathnameParts(url));
@@ -26,16 +27,19 @@ function createAppRscRouteMatcher(routes) {
 			if (sourcePathname === null) return null;
 			const urlParts = appRscPathnameParts(pathname);
 			const sourceParts = appRscPathnameParts(sourcePathname);
+			const matchedSourceRoute = trieMatch(routeTrie, sourceParts);
 			for (const entry of interceptLookup) {
 				if (!matchInterceptSource(sourceParts, entry)) continue;
 				const params = matchAppRscRoutePattern(urlParts, entry.targetPatternParts);
 				if (params === null) continue;
-				const sourceRoute = routes[entry.sourceRouteIndex];
-				const matchedSourceParams = sourceRoute ? matchAppRscRoutePattern(sourceParts, sourceRoute.patternParts) : null;
+				const concreteSourceRouteIndex = matchedSourceRoute && entry.sourceMatchPatternParts !== null ? routeIndexes.get(matchedSourceRoute.route) ?? entry.sourceRouteIndex : entry.sourceRouteIndex;
+				const sourceRoute = routes[concreteSourceRouteIndex];
+				const matchedSourceParams = matchedSourceRoute && entry.sourceMatchPatternParts !== null ? matchedSourceRoute.params : sourceRoute ? matchAppRscRoutePattern(sourceParts, sourceRoute.patternParts) : null;
 				if (matchedSourceParams === null && entry.sourceMatchPatternParts === null) continue;
 				const sourceParams = matchedSourceParams ?? createRouteParams();
 				return {
 					...entry,
+					sourceRouteIndex: concreteSourceRouteIndex,
 					matchedParams: mergeMatchedParams(sourceParams, params)
 				};
 			}
@@ -78,6 +82,7 @@ function createInterceptLookup(routes) {
 					targetPatternParts: intercept.targetPattern.split("/").filter(Boolean),
 					sourceMatchPattern,
 					sourceMatchPatternParts,
+					sourcePageSegments: intercept.sourcePageSegments ?? null,
 					interceptLayouts: intercept.interceptLayouts,
 					page: intercept.page,
 					__pageLoader: intercept.__pageLoader,
@@ -96,6 +101,7 @@ function createInterceptLookup(routes) {
 				targetPatternParts: intercept.targetPattern.split("/").filter(Boolean),
 				sourceMatchPattern,
 				sourceMatchPatternParts,
+				sourcePageSegments: intercept.sourcePageSegments ?? null,
 				interceptLayouts: intercept.interceptLayouts,
 				page: intercept.page,
 				__pageLoader: intercept.__pageLoader,

package/dist/server/app-segment-config.d.ts

@@ -33,6 +33,14 @@ type ResolveAppPageSegmentConfigOptions = {
  */
 declare function resolveAppPageSegmentConfig(options: ResolveAppPageSegmentConfigOptions): EffectiveAppPageSegmentConfig;
 declare function resolveAppPageFetchCacheMode(options: ResolveAppPageSegmentConfigOptions): FetchCacheMode | null;
+/**
+ * Resolve the `fetchCache` segment config exported by a route handler module.
+ *
+ * Route handlers have no layout chain, so the module's own export applies
+ * directly. Mirrors upstream's app-route module, which copies
+ * `userland.fetchCache` into the work store before invoking the handler.
+ */
+declare function resolveAppRouteHandlerFetchCacheMode(handler: Pick<AppRouteSegmentConfigModule, "fetchCache">): FetchCacheMode | null;
 declare function isEdgeRuntime(runtime: string | undefined): boolean;
 //#endregion
-export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig };
+export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig, resolveAppRouteHandlerFetchCacheMode };

package/dist/server/app-segment-config.js

@@ -88,8 +88,7 @@ function resolveAppPageSegmentConfig(options) {
 	}
 	if (config.dynamicConfig === "force-dynamic") config.revalidateSeconds = 0;
 	if (config.fetchCache === void 0) {
-		if (config.dynamicConfig === "force-dynamic") config.fetchCache = "force-no-store";
-		else if (config.dynamicConfig === "error") config.fetchCache = "only-cache";
+		if (config.dynamicConfig === "error") config.fetchCache = "only-cache";
 	}
 	if (config.dynamicParamsConfig === void 0 && (config.dynamicConfig === "error" || config.dynamicConfig === "force-static")) config.dynamicParamsConfig = false;
 	return config;
@@ -97,8 +96,18 @@ function resolveAppPageSegmentConfig(options) {
 function resolveAppPageFetchCacheMode(options) {
 	return resolveAppPageSegmentConfig(options).fetchCache ?? null;
 }
+/**
+* Resolve the `fetchCache` segment config exported by a route handler module.
+*
+* Route handlers have no layout chain, so the module's own export applies
+* directly. Mirrors upstream's app-route module, which copies
+* `userland.fetchCache` into the work store before invoking the handler.
+*/
+function resolveAppRouteHandlerFetchCacheMode(handler) {
+	return isRouteSegmentFetchCache(handler.fetchCache) ? handler.fetchCache : null;
+}
 function isEdgeRuntime(runtime) {
 	return isEdgeApiRuntime(runtime);
 }
 //#endregion
-export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig };
+export { isEdgeRuntime, resolveAppPageFetchCacheMode, resolveAppPageSegmentConfig, resolveAppRouteHandlerFetchCacheMode };

package/dist/server/app-server-action-execution.d.ts

@@ -173,6 +173,7 @@ type HandleServerActionRscRequestOptions<TElement, TRoute extends AppServerActio
   renderToReadableStream: (model: AppServerActionRscModel<TElement>, options: RenderServerActionRscStreamOptions<TTemporaryReferences>) => BodyInit | null | Promise<BodyInit | null>;
   reportRequestError: AppServerActionErrorReporter;
   resolveRouteFetchCacheMode?: (route: TRoute) => FetchCacheMode | null;
+  resolveRouteDynamicConfig?: (route: TRoute) => string | null | undefined;
   resolveRouteRuntime?: (route: TRoute) => AppServerActionRouteRuntime;
   request: Request;
   sanitizeErrorForClient: (error: unknown) => unknown;