vinext 0.1.2 → 0.1.3

package/dist/server/app-ppr-fallback-shell-render.js

@@ -0,0 +1,26 @@
+import { isPprFallbackShellAbortError, preparePprFallbackShellFinalRender, waitForPprFallbackShellCacheReady } from "../shims/ppr-fallback-shell.js";
+import { readAppPageBinaryStream } from "./app-page-execution.js";
+//#region src/server/app-ppr-fallback-shell-render.ts
+async function warmPprFallbackShellCaches(options) {
+	let warmupError = null;
+	const warmupDrain = readAppPageBinaryStream(options.renderToReadableStream(options.element, {
+		signal: options.state.abortController.signal,
+		onError(error, requestInfo, errorContext) {
+			if (options.state.abortController.signal.aborted || isPprFallbackShellAbortError(error)) return;
+			return options.onError(error, requestInfo, errorContext);
+		}
+	})).catch((error) => {
+		if (options.state.abortController.signal.aborted || isPprFallbackShellAbortError(error)) return;
+		warmupError = error;
+	});
+	try {
+		await waitForPprFallbackShellCacheReady(options.state);
+	} finally {
+		options.state.abortController.abort();
+		await warmupDrain;
+		preparePprFallbackShellFinalRender(options.state);
+	}
+	if (warmupError) throw warmupError;
+}
+//#endregion
+export { warmPprFallbackShellCaches };

package/dist/server/app-ppr-fallback-shell.d.ts

@@ -9,6 +9,18 @@ type AppPprFallbackShell = {
   pathname: string;
   params: Record<string, string | string[]>;
 };
+/**
+ * A fallback-shell cache entry as consumed by the dispatch layer.
+ * Produced at build time by the PPR prerender and served at request time
+ * when the exact cache entry for a dynamic child param is missing.
+ */
+type AppPagePprFallbackCacheShell = {
+  fallbackParamNames: readonly string[];
+  params: Record<string, string | string[]>;
+  pathname: string;
+};
+declare function markAppPprDynamicFallbackShellHtml(html: string): string;
+declare function isAppPprDynamicFallbackShellHtml(html: string): boolean;
 declare function createAppPprFallbackShell(route: AppPprFallbackShellRoute, matchedParams: Record<string, string | string[]>): AppPprFallbackShell | null;
 declare function createAppPprFallbackShells(route: AppPprFallbackShellRoute, matchedParams: Record<string, string | string[]>): AppPprFallbackShell[];
 declare function rewriteAppPprFallbackShellHtmlNavigation(options: {
@@ -18,4 +30,4 @@ declare function rewriteAppPprFallbackShellHtmlNavigation(options: {
   searchParams: URLSearchParams;
 }): string;
 //#endregion
-export { createAppPprFallbackShell, createAppPprFallbackShells, rewriteAppPprFallbackShellHtmlNavigation };
+export { AppPagePprFallbackCacheShell, createAppPprFallbackShell, createAppPprFallbackShells, isAppPprDynamicFallbackShellHtml, markAppPprDynamicFallbackShellHtml, rewriteAppPprFallbackShellHtmlNavigation };

package/dist/server/app-ppr-fallback-shell.js

@@ -1,6 +1,13 @@
 import { createInlineScriptTag } from "./html.js";
 import { createNavigationRuntimeRscMetadataScript } from "./app-ssr-stream.js";
 //#region src/server/app-ppr-fallback-shell.ts
+const PPR_DYNAMIC_FALLBACK_SHELL_MARKER = "<!--vinext-ppr-dynamic-fallback-shell-->";
+function markAppPprDynamicFallbackShellHtml(html) {
+	return html + PPR_DYNAMIC_FALLBACK_SHELL_MARKER;
+}
+function isAppPprDynamicFallbackShellHtml(html) {
+	return html.includes(PPR_DYNAMIC_FALLBACK_SHELL_MARKER);
+}
 function routeRootParamNames(route) {
 	return new Set(route.rootParamNames ?? []);
 }
@@ -79,4 +86,4 @@ function rewriteAppPprFallbackShellHtmlNavigation(options) {
 	return metadataScript + options.html;
 }
 //#endregion
-export { createAppPprFallbackShell, createAppPprFallbackShells, rewriteAppPprFallbackShellHtmlNavigation };
+export { createAppPprFallbackShell, createAppPprFallbackShells, isAppPprDynamicFallbackShellHtml, markAppPprDynamicFallbackShellHtml, rewriteAppPprFallbackShellHtmlNavigation };

package/dist/server/app-route-handler-dispatch.js

@@ -2,16 +2,17 @@ import { createRequestContext, runWithRequestContext } from "../shims/unified-re
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
 import { consumeDynamicUsage, getAndClearPendingCookies, getDraftModeCookieHeader, markDynamicUsage, setHeadersAccessPhase } from "../shims/headers.js";
-import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
+import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { setNavigationContext } from "../shims/navigation.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
+import { buildPageCacheTags } from "./implicit-tags.js";
 import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
 import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
-import { buildPageCacheTags } from "./implicit-tags.js";
 import { applyRouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
 import { executeAppRouteHandler } from "./app-route-handler-execution.js";
 import { readAppRouteHandlerCacheResponse } from "./app-route-handler-cache.js";
+import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
 //#region src/server/app-route-handler-dispatch.ts
 function isAppRouteHandlerFunction(value) {
 	return typeof value === "function";
@@ -32,6 +33,8 @@ async function runInRouteHandlerRevalidationContext(options, renderFn) {
 	}), async () => {
 		ensureFetchPatch();
 		setCurrentFetchSoftTags(buildRouteHandlerPageCacheTags(options.cleanPathname, [], options.routeSegments));
+		setCurrentFetchCacheMode(options.fetchCacheMode);
+		setCurrentForceDynamicFetchDefault(options.dynamicConfig === "force-dynamic");
 		await renderFn();
 	});
 }
@@ -56,6 +59,9 @@ async function dispatchAppRouteHandler(options) {
 		}), options.middlewareContext);
 	}
 	const resolvedHandlerFn = isAppRouteHandlerFunction(handlerFn) ? handlerFn : void 0;
+	const fetchCacheMode = resolveAppRouteHandlerFetchCacheMode(handler);
+	setCurrentFetchCacheMode(fetchCacheMode);
+	setCurrentForceDynamicFetchDefault(handler.dynamic === "force-dynamic");
 	if (revalidateSeconds !== null && shouldReadAppRouteHandlerCache({
 		dynamicConfig: handler.dynamic,
 		handlerFn: resolvedHandlerFn,
@@ -96,6 +102,7 @@ async function dispatchAppRouteHandler(options) {
 					cleanPathname: options.cleanPathname,
 					draftModeSecret: options.draftModeSecret,
 					dynamicConfig: handler.dynamic,
+					fetchCacheMode,
 					routePattern: route.pattern,
 					routeSegments: route.routeSegments
 				}, renderFn);

package/dist/server/app-route-handler-policy.d.ts

@@ -3,6 +3,7 @@ import { RouteHandlerHttpMethod, RouteHandlerModule } from "./app-route-handler-
 //#region src/server/app-route-handler-policy.d.ts
 type AppRouteHandlerModule = {
   dynamic?: string;
+  fetchCache?: unknown;
   revalidate?: unknown;
 } & RouteHandlerModule;
 type AppRouteHandlerFunction = (...args: unknown[]) => unknown;

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

@@ -1,9 +1,11 @@
 import "./server-globals.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { cloneRequestWithHeaders, filterInternalHeaders, isOpenRedirectShaped } from "./request-pipeline.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { resolveStaticAssetSignal } from "./worker-utils.js";
+import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import rscHandler, { __assetPrefix, __basePath } from "virtual:vinext-rsc-entry";
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 //#region src/server/app-router-entry.ts
@@ -23,7 +25,10 @@ async function handleRequest(request, env, ctx) {
 	}
 	if (isNextStaticPath(url.pathname, __workerBasePath, __workerAssetPathPrefix)) return notFoundStaticAssetResponse();
 	{
+		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(request);
 		const filteredHeaders = filterInternalHeaders(request.headers);
+		const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParamsPayload);
+		if (prerenderRouteParamsHeader !== null) filteredHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
 		request = cloneRequestWithHeaders(request, filteredHeaders);
 	}
 	const handleFn = () => rscHandler(request, ctx);

package/dist/server/app-rsc-cache-busting.js

@@ -1,6 +1,7 @@
 import { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.js";
 import { fnv1a64 } from "../utils/hash.js";
 import { parseAppRscRenderMode } from "./app-rsc-render-mode.js";
+import { applyDeploymentIdHeader } from "../utils/deployment-id.js";
 //#region src/server/app-rsc-cache-busting.ts
 /**
 * RSC cache-busting hashes cover the headers that make an RSC payload vary.
@@ -148,6 +149,7 @@ function createRscRequestHeaders(options = {}) {
 		Accept: VINEXT_RSC_CONTENT_TYPE,
 		["RSC"]: "1"
 	});
+	applyDeploymentIdHeader(headers);
 	if (options.interceptionContext !== void 0 && options.interceptionContext !== null) headers.set(VINEXT_INTERCEPTION_CONTEXT_HEADER, options.interceptionContext);
 	if (options.mountedSlotsHeader !== void 0 && options.mountedSlotsHeader !== null) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, options.mountedSlotsHeader);
 	if (options.clientReuseManifestHeader !== void 0 && options.clientReuseManifestHeader !== null) headers.set(VINEXT_CLIENT_REUSE_MANIFEST_HEADER, options.clientReuseManifestHeader);

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,17 @@ type RenderNotFoundOptions<TRoute> = {
   scriptNonce?: string;
 };
 type RenderPagesFallbackOptions = {
+  allowRscDocumentFallback?: boolean;
+  appRouteMatch?: {
+    route: {
+      isDynamic: boolean;
+      pattern: string;
+    };
+  } | null;
   isRscRequest: boolean;
+  matchKind?: "dynamic" | "static";
   middlewareContext: AppRscMiddlewareContext;
+  pathname?: string;
   request: Request;
   url: URL;
 };
@@ -122,6 +144,7 @@ type NavigationContextValue = {
 };
 type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   basePath: string;
+  cacheComponents?: boolean;
   clearRequestContext: () => void;
   configHeaders: NextHeader[];
   configRedirects: NextRedirect[];
@@ -150,6 +173,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

@@ -4,27 +4,31 @@ 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 { 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 +42,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 +64,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,6 +101,13 @@ function requestWithoutRscCacheBustingSearchParam(request) {
 	stripRscCacheBustingSearchParam(url);
 	return cloneRequestWithUrl(request.body ? request.clone() : request, url.toString());
 }
+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) {
 	const handlerStart = process.env.NODE_ENV !== "production" ? performance.now() : 0;
 	if (process.env.NODE_ENV !== "production") {
@@ -92,6 +118,8 @@ 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 getResolvedSearchParams = () => new URL(resolvedUrl, url).searchParams;
 	const canonicalPathname = cleanPathname;
 	const basePathState = {
 		basePath: options.basePath,
@@ -124,12 +152,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 +179,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 +230,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 +265,85 @@ 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) => match === null || match.route.isDynamic ? await options.renderPagesFallback?.({
+		appRouteMatch: match ?? null,
+		allowRscDocumentFallback: didMiddlewareRewrite,
+		isRscRequest,
+		matchKind,
+		middlewareContext,
+		pathname: resolvedUrl,
+		request,
+		url
+	}) ?? null : null;
+	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 (!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 +359,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 +406,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);

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

@@ -78,6 +78,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 +97,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 };