vinext 1.4.1 → 1.4.2

package/dist/server/api-handler.d.ts

@@ -14,5 +14,7 @@ export declare function handleApiRoute(runner: ModuleImporter, req: IncomingMess
   allowedRevalidateHeaderKeys?: readonly string[];
   trailingSlash?: boolean;
   skipTrailingSlashRedirect?: boolean;
+  /** Edge API request pathname, with any basePath the dev server stripped restored. */
+  requestPathname?: string;
 }): Promise<boolean>;
 //#endregion

package/dist/server/api-handler.js

@@ -1,4 +1,3 @@
-import { hasBasePath } from "../utils/base-path.js";
 import { matchRoute } from "../routing/pages-router.js";
 import "./server-globals.js";
 import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
@@ -94,7 +93,7 @@ function readEdgeRequestBody(req) {
 		req.on("error", (error) => controller.error(error));
 	} });
 }
-function createEdgeApiRequest(req, res, url, params, nextConfig) {
+function createEdgeApiRequest(req, res, url, params, requestPathname) {
 	const headers = new Headers();
 	for (const [name, value] of Object.entries(req.headers)) {
 		if (name.startsWith(":")) continue;
@@ -104,8 +103,7 @@ function createEdgeApiRequest(req, res, url, params, nextConfig) {
 	const proto = resolveRequestProtocol(req);
 	const host = resolveRequestHost(req, "localhost");
 	const requestUrl = new URL(req.url ?? url, `${proto}://${host}`);
-	const basePath = nextConfig?.basePath;
-	if (basePath && !hasBasePath(requestUrl.pathname, basePath)) requestUrl.pathname = `${basePath}${requestUrl.pathname}`;
+	if (requestPathname !== void 0) requestUrl.pathname = requestPathname;
 	const query = mergeRouteParamsIntoQuery(parseQueryString(url), params);
 	requestUrl.search = urlQueryToSearchParams(query).toString();
 	const signal = signalFromNodeResponse(res);
@@ -250,7 +248,7 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 	try {
 		const apiModule = await importModule(runner, route.filePath);
 		if (isEdgeApiRouteModule(apiModule)) {
-			const nextRequest = new NextRequest(createEdgeApiRequest(req, res, url, params, nextConfig), nextConfig ? { nextConfig: {
+			const nextRequest = new NextRequest(createEdgeApiRequest(req, res, url, params, nextConfig?.requestPathname), nextConfig ? { nextConfig: {
 				basePath: nextConfig.basePath,
 				i18n: nextConfig.i18n ?? void 0,
 				trailingSlash: nextConfig.trailingSlash,

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

@@ -6,6 +6,7 @@ import { RequestCookies, ResponseCookies } from "../shims/server.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { getSetCookieName } from "./cookie-utils.js";
 import "../shims/internal/cookies.js";
+import { isStreamedActionRedirectResponse, markStreamedActionRedirectResponse } from "./app-rsc-response-finalizer.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage } from "./server-action-not-found.js";
 //#region src/server/app-action-forwarding.ts
 const ACTION_FORWARD_FORBIDDEN_HEADERS = /* @__PURE__ */ new Set([
@@ -71,11 +72,12 @@ function filterActionForwardResponse(response, sourceMiddlewareHeaders, sourceMi
 	for (const [key, value] of response.headers) if (!ACTION_FORWARD_FORBIDDEN_HEADERS.has(key.toLowerCase())) headers.set(key, value);
 	for (const setCookie of response.headers.getSetCookie()) headers.append("set-cookie", setCookie);
 	const preserveResponseStatus = response.headers.get("x-nextjs-action-not-found") === "1" || response.headers.has("x-action-redirect");
-	return new Response(response.body, {
+	const forwardedResponse = new Response(response.body, {
 		headers,
 		status: preserveResponseStatus ? response.status : sourceMiddlewareStatus ?? response.status,
 		statusText: response.statusText
 	});
+	return isStreamedActionRedirectResponse(response) ? markStreamedActionRedirectResponse(forwardedResponse) : forwardedResponse;
 }
 function emptyActionForwardResponse(middlewareContext) {
 	const headers = new Headers(middlewareContext.headers ?? void 0);

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

@@ -23,11 +23,11 @@ import { navigationPlanner } from "./navigation-planner.js";
 import { decodeRedirectError, isRedirectError } from "../shims/navigation-errors.js";
 import { beginAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { getBfcacheIdMapContext, getNavigationContext, setNavigationContext } from "../shims/navigation-context-state.js";
-import { DYNAMIC_NAVIGATION_CACHE_TTL, PREFETCH_CACHE_TTL, __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponse, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, deletePrefetchResponseSnapshot, disableNavigationResponsePrefetchCacheReuse, getClientNavigationRenderContext, getMountedSlotsHeader, getPrefetchCache, hasPrefetchCacheEntryForNavigation, invalidateDynamicPrefetchCache, invalidatePrefetchCache, invalidateVisitedResponsePrefetches, parseRenderedPathAndSearchHeader, preloadHybridClientRouteOwner, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveLoadedHybridClientRewriteHref, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, seedPrefetchResponseSnapshot, setClientParams, setMountedSlotsHeader, setPendingPathname, trackAppRouterNavigationInFlight, useRouter } from "../shims/navigation.js";
+import { DYNAMIC_NAVIGATION_CACHE_TTL, PREFETCH_CACHE_TTL, __basePath, activateNavigationSnapshot, appRouterInstance, commitClientNavigationState, consumePrefetchResponse, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, deletePrefetchResponseSnapshot, disableNavigationResponsePrefetchCacheReuse, getClientNavigationRenderContext, getMountedSlotsHeader, getPrefetchCache, hasPrefetchCacheEntryForNavigation, invalidateDynamicPrefetchCache, invalidatePrefetchCache, invalidateVisitedResponsePrefetches, parseRenderedPathAndSearchHeader, preloadHybridClientRouteOwner, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveLoadedHybridClientRewriteHref, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, seedPrefetchResponseSnapshot, setClientParams, setMountedSlotsHeader, setPendingPathname, trackAppRouterNavigationInFlight, useRouter } from "../shims/navigation.js";
 import { AppRouterScrollCommitProvider } from "../shims/app-router-scroll.js";
 import { chunksToReadableStream, createProgressiveRscStream, getVinextBrowserGlobal } from "./app-browser-stream.js";
 import { createMountedLayoutsHeader, holdsSkippedLayouts } from "./app-mounted-layouts.js";
-import { BfcacheIdentityMapContext, bindAppElementsRenderedSearch, setAppElementsRenderedSearch } from "../shims/slot.js";
+import { BfcacheIdentityMapContext, bindAppElementsRenderedSearch, isBfcacheIdentityRetained, setAppElementsRenderedSearch } from "../shims/slot.js";
 import { COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, isCacheRestorableAppPayloadMetadata, isCompleteAppPayloadMetadata, resolveInterceptionContextFromPreviousNextUrl } from "./app-browser-state.js";
 import { clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch, navigateDocumentDirectly } from "./app-browser-navigation-controller.js";
 import { createAppRouteTree } from "./app-route-tree.js";
@@ -195,6 +195,12 @@ const RSC_HMR_SETTLE_DELAY_MS = 150;
 const DEFAULT_GLOBAL_ERROR_COMPONENT = DefaultGlobalError;
 let latestRscHmrUpdateId = 0;
 let synchronousPopstateScrollRestoreNavigationId = null;
+let pendingHistoryRestoreCommit = null;
+function flushPendingHistoryRestoreCommit() {
+	const commit = pendingHistoryRestoreCommit;
+	pendingHistoryRestoreCommit = null;
+	commit?.();
+}
 function waitForRscHmrSettle(delayMs = RSC_HMR_SETTLE_DELAY_MS) {
 	return new Promise((resolve) => {
 		window.setTimeout(resolve, delayMs);
@@ -212,6 +218,10 @@ function restoreHistoryStateSnapshot(historyState, navId, onApprovedBeforeCommit
 				beforeCommit: () => {
 					onApprovedBeforeCommit?.();
 					beforeCommit();
+					if (!restoreCopiedExternalHistoryEntry) {
+						activateNavigationSnapshot();
+						pendingHistoryRestoreCommit = () => commitClientNavigationState(navId);
+					}
 				},
 				navId,
 				state,
@@ -223,7 +233,8 @@ function restoreHistoryStateSnapshot(historyState, navId, onApprovedBeforeCommit
 	clientNavigationCacheGeneration += 1;
 	revokeHistoryRestoreNavigationReuse(visitedResponseCache);
 	disableNavigationResponsePrefetchCacheReuse();
-	commitClientNavigationState(navId, { releaseSnapshot: false });
+	if (restoreCopiedExternalHistoryEntry) commitClientNavigationState(navId, { releaseSnapshot: false });
+	else flushPendingHistoryRestoreCommit();
 	return true;
 }
 function getBrowserRouterState() {
@@ -1393,7 +1404,10 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 								currentElements: navigationInitiationState.elements,
 								currentLayoutIds: navigationInitiationState.layoutIds,
 								currentParams: navigationInitiationState.navigationSnapshot.params,
+								isBfcacheIdentityRetained,
 								routeManifest,
+								shownElements: getBrowserRouterState().elements,
+								targetElements: optimisticPayload.elements,
 								targetRouteParams: optimisticPayload.routeParams,
 								targetUrlParts: optimisticPayload.urlParts,
 								template: optimisticPayload.template
@@ -1635,7 +1649,10 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 		discardPendingNavigation: () => {
 			if (browserNavigationController.discardPendingNavigation(historyController.readCurrentTreeSnapshot())) navigationAbortCoordinator.abortActive();
 		},
-		flushCommittingNavigationUrl: () => browserNavigationController.flushCommittingNavigationUrl()
+		flushCommittingNavigationUrl: () => {
+			flushPendingHistoryRestoreCommit();
+			browserNavigationController.flushCommittingNavigationUrl();
+		}
 	});
 	const handlePopstate = createPopstateRestoreHandler({
 		getActiveNavigationId: browserNavigationController.getActiveNavigationId.bind(browserNavigationController),

package/dist/server/app-elements.d.ts

@@ -1,6 +1,9 @@
 import { APP_ARTIFACT_COMPATIBILITY_KEY, APP_BFCACHE_SEGMENT_IDENTITIES_KEY, APP_CACHE_ENTRY_REUSE_PROOF_KEY, APP_DYNAMIC_STALE_TIME_KEY, APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_LAYOUT_IDS_KEY, APP_ROOT_LAYOUT_KEY, APP_ROUTE_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_SLOT_BINDINGS_KEY, APP_SOURCE_PAGE_SEGMENTS_KEY, APP_STATIC_SIBLINGS_KEY, APP_UNMATCHED_SLOT_WIRE_VALUE, AppElementValue, AppElements, AppElementsBfcacheSegmentIdentities, AppElementsInterception, AppElementsSlotBinding, AppElementsWire, AppOutgoingElements, AppWireElements, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata } from "./app-elements-wire.js";
 //#region src/server/app-elements.d.ts
 export declare const APP_PREFETCH_LOADING_SHELL_MARKER_KEY = "__prefetchLoadingShell";
+type AppElementsStateKeyRebinder = (stateKey: string) => string;
+export declare function setOptimisticStateKeyRebinder(elements: Record<string, unknown>, rebind: AppElementsStateKeyRebinder): void;
+export declare function readOptimisticStateKeyRebinder(elements: AppElements): AppElementsStateKeyRebinder | null;
 /** Prefix of the element that streams a route's generateMetadata() tags in the body. */
 export declare const APP_STREAMING_METADATA_BODY_ID_PREFIX = "__vinext_streaming_metadata_body:";
 export declare function getMountedSlotIds(elements: AppElements): string[];

package/dist/server/app-elements.js

@@ -2,6 +2,19 @@ import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import { APP_ARTIFACT_COMPATIBILITY_KEY, APP_BFCACHE_SEGMENT_IDENTITIES_KEY, APP_CACHE_ENTRY_REUSE_PROOF_KEY, APP_DYNAMIC_STALE_TIME_KEY, APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_LAYOUT_IDS_KEY, APP_ROOT_LAYOUT_KEY, APP_ROUTE_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_SLOT_BINDINGS_KEY, APP_SOURCE_PAGE_SEGMENTS_KEY, APP_STATIC_SIBLINGS_KEY, APP_UNMATCHED_SLOT_WIRE_VALUE, AppElementsWire, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata } from "./app-elements-wire.js";
 //#region src/server/app-elements.ts
 const APP_PREFETCH_LOADING_SHELL_MARKER_KEY = "__prefetchLoadingShell";
+/**
+* An optimistic shell's rebinder from the learned URL's segment state keys to
+* the target's. Only the browser sets it, on the elements it builds a shell
+* from, so it never reaches the wire.
+*/
+const APP_OPTIMISTIC_STATE_KEY_REBINDER_KEY = "__optimisticStateKeyRebinder";
+function setOptimisticStateKeyRebinder(elements, rebind) {
+	elements[APP_OPTIMISTIC_STATE_KEY_REBINDER_KEY] = rebind;
+}
+function readOptimisticStateKeyRebinder(elements) {
+	const rebind = Reflect.get(elements, APP_OPTIMISTIC_STATE_KEY_REBINDER_KEY);
+	return typeof rebind === "function" ? rebind : null;
+}
 /** Prefix of the element that streams a route's generateMetadata() tags in the body. */
 const APP_STREAMING_METADATA_BODY_ID_PREFIX = "__vinext_streaming_metadata_body:";
 function getMountedSlotIds(elements) {
@@ -18,4 +31,4 @@ function resolveVisitedResponseInterceptionContext(requestInterceptionContext, p
 	return payloadInterceptionContext ?? requestInterceptionContext;
 }
 //#endregion
-export { APP_ARTIFACT_COMPATIBILITY_KEY, APP_BFCACHE_SEGMENT_IDENTITIES_KEY, APP_CACHE_ENTRY_REUSE_PROOF_KEY, APP_DYNAMIC_STALE_TIME_KEY, APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_LAYOUT_IDS_KEY, APP_PREFETCH_LOADING_SHELL_MARKER_KEY, APP_ROOT_LAYOUT_KEY, APP_ROUTE_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_SLOT_BINDINGS_KEY, APP_SOURCE_PAGE_SEGMENTS_KEY, APP_STATIC_SIBLINGS_KEY, APP_STREAMING_METADATA_BODY_ID_PREFIX, APP_UNMATCHED_SLOT_WIRE_VALUE, AppElementsWire, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, getMountedSlotIds, getMountedSlotIdsHeader, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, resolveVisitedResponseInterceptionContext };
+export { APP_ARTIFACT_COMPATIBILITY_KEY, APP_BFCACHE_SEGMENT_IDENTITIES_KEY, APP_CACHE_ENTRY_REUSE_PROOF_KEY, APP_DYNAMIC_STALE_TIME_KEY, APP_INTERCEPTION_CONTEXT_KEY, APP_INTERCEPTION_KEY, APP_LAYOUT_IDS_KEY, APP_PREFETCH_LOADING_SHELL_MARKER_KEY, APP_ROOT_LAYOUT_KEY, APP_ROUTE_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_SLOT_BINDINGS_KEY, APP_SOURCE_PAGE_SEGMENTS_KEY, APP_STATIC_SIBLINGS_KEY, APP_STREAMING_METADATA_BODY_ID_PREFIX, APP_UNMATCHED_SLOT_WIRE_VALUE, AppElementsWire, UNMATCHED_SLOT, buildOutgoingAppPayload, compareAppElementsSlotIds, getMountedSlotIds, getMountedSlotIdsHeader, isAppElementsRecord, normalizeAppElements, normalizeAppElementsSlotBindings, readAppElementsMetadata, readOptimisticStateKeyRebinder, resolveVisitedResponseInterceptionContext, setOptimisticStateKeyRebinder };

package/dist/server/app-fallback-renderer.js

@@ -1,10 +1,10 @@
 import { runOutsideRequestScopes } from "../shims/internal/als-registry.js";
 import { shareIsolatePromise } from "./isolate-shared-promise.js";
-import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
-import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { renderAppPageErrorBoundary, renderAppPageHttpAccessFallback } from "./app-page-boundary-render.js";
+import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
 import { DEFAULT_GLOBAL_NOT_FOUND_MODULE } from "./default-global-not-found-module.js";
 import { DEFAULT_NOT_FOUND_MODULE } from "./default-http-access-fallback-modules.js";
+import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 //#region src/server/app-fallback-renderer.ts
 const EMPTY_MW_CTX = {
 	headers: null,

package/dist/server/app-optimistic-routing.d.ts

@@ -10,6 +10,8 @@ export type OptimisticRouteTemplate = {
   omittedBfcacheSegmentIds: readonly string[];
   omittedLayoutIds: readonly string[];
   pageElementIds: readonly string[];
+  /** The navigation params of the URL the template was learned from. */
+  params: Readonly<Record<string, string | string[]>>;
   routeId: string;
 };
 type OptimisticNavigationPayload = {
@@ -48,7 +50,7 @@ export declare function createOptimisticRouteTemplate(options: {
   mountedSlotsHeader: string | null;
   routeManifest: BrowserRouteManifest;
 }): OptimisticRouteTemplate | null;
-export declare function createOptimisticRouteElements(template: OptimisticRouteTemplate): AppElements;
+export declare function createOptimisticRouteElements(template: OptimisticRouteTemplate, params?: Readonly<Record<string, string | string[]>>): AppElements;
 /**
  * The optimistic shell reveals the prefetch's streamed metadata, such as its
  * title. React won't hide revealed content again in a transition, so while the
@@ -77,7 +79,16 @@ export declare function canCommitOptimisticRouteTemplate(options: {
   currentElements: AppElements;
   currentLayoutIds: readonly string[];
   currentParams: Readonly<Record<string, string | string[]>>;
+  /** Whether a hidden BFCache entry retains a segment identity. */
+  isBfcacheIdentityRetained?: (identity: string) => boolean;
   routeManifest: BrowserRouteManifest;
+  /**
+   * The elements on screen, when a shell earlier in this navigation replaced
+   * the current ones. Defaults to `currentElements`.
+   */
+  shownElements?: AppElements;
+  /** The shell's elements for the target. */
+  targetElements?: AppElements;
   targetRouteParams: Readonly<Record<string, string | string[]>>;
   targetUrlParts: readonly string[];
   template: OptimisticRouteTemplate;

package/dist/server/app-optimistic-routing.js

@@ -4,10 +4,10 @@ import { decodeMatchedParams, splitPathnameForRouteMatch } from "../routing/util
 import { extractRawRoutePatternParams, matchRoutePattern } from "../routing/route-pattern.js";
 import { buildOptimisticRouteTrie, matchOptimisticRouteTrie } from "../routing/optimistic-route-trie.js";
 import { stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
-import { AppElementsWire } from "./app-elements-wire.js";
-import "./app-elements.js";
+import { APP_BFCACHE_SEGMENT_IDENTITIES_KEY, AppElementsWire } from "./app-elements-wire.js";
+import { setOptimisticStateKeyRebinder } from "./app-elements.js";
 import { createNestedBfcacheSlotSegmentId, deriveBfcacheSegmentIdentity, isNestedBfcacheSlotSegmentId } from "./bfcache-identity.js";
-import { canonicalizeAppPageParams, resolveAppPagePatternStateKey, resolveAppPageSemanticSegmentStateKey } from "./app-page-segment-state.js";
+import { APP_PAGE_DEFAULT_SEGMENT_KEY, APP_PAGE_SEGMENT_KEY, canonicalizeAppPageParams, createAppPageSegmentStateKeyRebinder, resolveAppPagePatternStateKey, resolveAppPageSemanticSegmentStateKey } from "./app-page-segment-state.js";
 import { Suspense, createElement, isValidElement } from "react";
 //#region src/server/app-optimistic-routing.ts
 const routeTrieCache = /* @__PURE__ */ new WeakMap();
@@ -114,6 +114,18 @@ function resolveTargetBfcacheSegmentIdentity(options) {
 		const segmentParams = binding.state === "active" && binding.slotPatternParts !== void 0 && binding.slotPatternParts.length > 0 && !binding.slotParamNames?.every((name) => routeParamNames.has(name)) ? matchRoutePattern(options.targetUrlParts, binding.slotPatternParts) ?? options.targetRouteParams : options.targetRouteParams;
 		const ownerLayout = binding.ownerLayoutId ? options.routeManifest.segmentGraph.layouts.get(binding.ownerLayoutId) : void 0;
 		const ownerStateKey = ownerLayout ? resolveAppPagePatternStateKey(ownerLayout.patternParts, options.targetRouteParams) : "";
+		const deriveLevelIdentity = (segmentKeys) => {
+			const identityKey = JSON.stringify(segmentKeys);
+			return deriveBfcacheSegmentIdentity({
+				activeRouteGraphId: null,
+				boundSegmentKey: ownerStateKey ? JSON.stringify([ownerStateKey, identityKey]) : identityKey,
+				interceptionTargetRouteGraphId: null,
+				kind: "slot",
+				ownerLayoutGraphId: binding.ownerLayoutId,
+				slotGraphId: binding.slotId,
+				state: binding.state
+			});
+		};
 		const boundSegmentKeys = [];
 		let level = 0;
 		for (const segment of binding.routeSegments ?? []) {
@@ -125,17 +137,9 @@ function resolveTargetBfcacheSegmentIdentity(options) {
 				segment
 			}, segmentParams));
 			if (createNestedBfcacheSlotSegmentId(binding.slotId, level) !== options.segmentId) continue;
-			const identityKey = JSON.stringify(boundSegmentKeys);
-			return deriveBfcacheSegmentIdentity({
-				activeRouteGraphId: null,
-				boundSegmentKey: ownerStateKey ? JSON.stringify([ownerStateKey, identityKey]) : identityKey,
-				interceptionTargetRouteGraphId: null,
-				kind: "slot",
-				ownerLayoutGraphId: binding.ownerLayoutId,
-				slotGraphId: binding.slotId,
-				state: binding.state
-			});
+			return deriveLevelIdentity(boundSegmentKeys);
 		}
+		if (level > 0 && createNestedBfcacheSlotSegmentId(binding.slotId, level + 1) === options.segmentId) return deriveLevelIdentity([...boundSegmentKeys, binding.state === "default" ? APP_PAGE_DEFAULT_SEGMENT_KEY : APP_PAGE_SEGMENT_KEY]);
 		if (level === 0 && createNestedBfcacheSlotSegmentId(binding.slotId, 1) === options.segmentId) return deriveBfcacheSegmentIdentity({
 			activeRouteGraphId: null,
 			boundSegmentKey: ownerStateKey ? JSON.stringify([ownerStateKey, ""]) : "",
@@ -188,18 +192,31 @@ function createOptimisticRouteTemplate(options) {
 	if (options.allowLoadingShell && (routeElement === void 0 || routeElement === null)) return null;
 	const pageElementIds = getPageElementIds(options.elements, match.route);
 	if (pageElementIds.length === 0) return null;
+	const urlParts = hrefToRouteParts(options.href, options.basePath);
+	if (urlParts === null) return null;
 	return {
 		elements: options.elements,
 		mountedSlotsHeader: options.mountedSlotsHeader,
 		omittedBfcacheSegmentIds: options.elements["__prefetchLoadingShell"] === "LoadingBoundary" ? getOmittedBfcacheSegmentIds(options.elements) : [],
 		omittedLayoutIds: options.elements["__prefetchLoadingShell"] === "LoadingBoundary" ? metadata.layoutIds.filter((layoutId) => !Object.hasOwn(options.elements, layoutId)) : [],
 		pageElementIds,
+		params: resolveOptimisticNavigationParams({
+			match,
+			rawUrlParts: urlParts.raw,
+			routeManifest: options.routeManifest,
+			urlParts: urlParts.normalized
+		}).navigationParams,
 		routeId: match.route.id
 	};
 }
-function createOptimisticRouteElements(template) {
+function createOptimisticRouteElements(template, params = template.params) {
 	const elements = { ...template.elements };
 	for (const pageElementId of template.pageElementIds) elements[pageElementId] = createElement(OptimisticRouteSegment);
+	const reify = createAppPageSegmentStateKeyRebinder(template.params, params);
+	if (reify === null) return elements;
+	setOptimisticStateKeyRebinder(elements, reify);
+	const identities = AppElementsWire.readMetadata(template.elements).bfcacheSegmentIdentities;
+	if (Object.keys(identities).length > 0) elements[APP_BFCACHE_SEGMENT_IDENTITIES_KEY] = Object.fromEntries(Object.entries(identities).map(([id, identity]) => [id, reify(identity)]));
 	return elements;
 }
 function findStreamingMetadataBody(elements) {
@@ -244,9 +261,14 @@ function keepOptimisticStreamingMetadata(elements, optimisticElements, navigatio
 * loading boundary does not re-trigger.
 */
 function canCommitOptimisticRouteTemplate(options) {
+	const currentIdentities = AppElementsWire.readMetadata(options.currentElements).bfcacheSegmentIdentities;
+	const { isBfcacheIdentityRetained, targetElements } = options;
+	if (isBfcacheIdentityRetained && targetElements) {
+		const shownIdentities = new Set(Object.values(options.shownElements ? AppElementsWire.readMetadata(options.shownElements).bfcacheSegmentIdentities : currentIdentities));
+		for (const identity of Object.values(AppElementsWire.readMetadata(targetElements).bfcacheSegmentIdentities)) if (!shownIdentities.has(identity) && isBfcacheIdentityRetained(identity)) return false;
+	}
 	if (options.template.omittedLayoutIds.length === 0 && options.template.omittedBfcacheSegmentIds.length === 0) return true;
 	const currentLayoutIds = new Set(options.currentLayoutIds);
-	const currentIdentities = AppElementsWire.readMetadata(options.currentElements).bfcacheSegmentIdentities;
 	for (const layoutId of options.template.omittedLayoutIds) {
 		if (!currentLayoutIds.has(layoutId)) continue;
 		if (!Object.hasOwn(options.currentElements, layoutId)) continue;
@@ -302,7 +324,7 @@ function resolveOptimisticNavigationPayload(options) {
 		urlParts: urlParts.normalized
 	});
 	return {
-		elements: createOptimisticRouteElements(template),
+		elements: createOptimisticRouteElements(template, navigationParams),
 		params: navigationParams,
 		routeParams,
 		template,

package/dist/server/app-page-boundary-render.js

@@ -20,9 +20,9 @@ import { hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRou
 import { renderAppPageBoundaryResponse, resolveAppPageErrorBoundary, resolveAppPageHttpAccessBoundaryModule, wrapAppPageBoundaryElement } from "./app-page-boundary.js";
 import { createRouteNotFoundHeadPlanOptions, recoverAppPageRouteHead, resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport } from "./app-page-http-access-fallback-metadata.js";
 import "./app-rsc-route-matching.js";
-import { createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageSourcePage } from "./app-page-route-wiring.js";
-import { resolveSlotParamOverrides } from "./app-page-element-builder.js";
+import { resolveSlotParamOverrides } from "./app-page-navigation-params.js";
 import { createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, renderAppPageHtmlResponse } from "./app-page-stream.js";
+import { createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageSourcePage } from "./app-page-route-wiring.js";
 import { Fragment, Suspense, createElement } from "react";
 //#region src/server/app-page-boundary-render.ts
 async function AppPageBoundaryStreamedMetadata(props) {

package/dist/server/app-page-cache-render.js

@@ -4,8 +4,8 @@ import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js"
 import { getCollectedFetchTags } from "../shims/fetch-cache.js";
 import { readStreamAsText } from "../utils/text-stream.js";
 import { buildAppPageFontLinkHeader, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
-import { recordAppPageRenderError, traceAppPageRender } from "./app-page-tracing.js";
 import { buildAppPageLinkHeader, createAppPageSsrErrorHandler, isAppSsrRenderResult } from "./app-page-stream.js";
+import { recordAppPageRenderError, traceAppPageRender } from "./app-page-tracing.js";
 import { consumeAppPageRenderObservationState, createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope } from "./app-page-render-observation.js";
 import { buildAppPageTags } from "./implicit-tags.js";
 //#region src/server/app-page-cache-render.ts

package/dist/server/app-page-dispatch.d.ts

@@ -15,7 +15,7 @@ import { FetchCacheMode } from "../shims/fetch-cache-state.js";
 import "../shims/fetch-cache.js";
 import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
 import { WarmPprFallbackShellCachesOptions } from "./app-ppr-fallback-shell-render.js";
-import { ValidateAppPageDynamicParamsOptions } from "./app-page-request.js";
+import { AppPageInterceptState, ValidateAppPageDynamicParamsOptions } from "./app-page-request.js";
 import { ReactNode } from "react";
 import { ReactFormState } from "react-dom/client";
 //#region src/server/app-page-dispatch.d.ts
@@ -96,10 +96,17 @@ type AppPageModule = {
   revalidate?: unknown;
 };
 type AppPageDispatchSlot = {
+  configLayouts?: readonly (AppPageModule | null | undefined)[] | null;
+  configLayoutTreePositions?: readonly number[] | null;
   default?: AppPageModule | null;
+  layout?: AppPageModule | null;
+  layoutIndex?: number;
   loading?: AppPageModule | null;
   loadings?: readonly (AppPageModule | null | undefined)[] | null;
+  name?: string;
+  ownerTreePosition?: number | null;
   page?: AppPageModule | null;
+  routeSegments?: readonly string[] | null;
   slotPatternParts?: readonly string[] | null;
   slotParamNames?: readonly string[] | null;
 };
@@ -184,6 +191,8 @@ export type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   ensureRouteLoaded?: (route: TRoute) => unknown;
   fetchCache?: FetchCacheMode | null;
   findIntercept: (pathname: string) => AppPageDispatchIntercept | null;
+  /** This request's intercept, which dispatch resolves once before rendering. */
+  interceptState?: AppPageInterceptState<TRoute, unknown>;
   formState?: ReactFormState | null;
   actionError?: unknown;
   actionFailed?: boolean;

package/dist/server/app-page-dispatch.js

@@ -1,7 +1,7 @@
 import { closeAfterResponse, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import "../utils/protocol-headers.js";
 import { VINEXT_INTERCEPTION_ID_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
-import { VINEXT_MOUNTED_LAYOUTS_HEADER } from "./headers.js";
+import { VINEXT_MOUNTED_LAYOUTS_HEADER, VINEXT_PARAMS_HEADER } from "./headers.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { beginRouteCacheability, isRouteCacheabilityIdentityProbe, isRouteCacheabilityProbe, markRouteCacheabilityPatternDynamic, readRouteCacheabilityState } from "../shims/cacheability-classification.js";
@@ -21,16 +21,17 @@ import { resolveUncacheableCacheControl } from "./app-page-response.js";
 import { buildRscRedirectFlightStream } from "./app-rsc-redirect-flight.js";
 import { buildAppPageSpecialErrorResponse, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders } from "./app-page-execution.js";
 import { resolveAppPageLayoutHttpAccessBoundary, resolveAppPageParentHttpAccessBoundary, resolveAppPageRootHttpAccessBoundaryTreePosition } from "./app-page-boundary.js";
+import { resolveAppPageNavigationParams } from "./app-page-navigation-params.js";
+import { createAppPageRscErrorTracker } from "./app-page-stream.js";
 import { isAppClientReference } from "./app-render-dependency.js";
 import { resolveAppPageTraceOperation } from "./app-page-tracing.js";
-import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
-import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
-import { createAppPageRscErrorTracker } from "./app-page-stream.js";
 import { getDefaultHttpAccessFallbackModule } from "./default-http-access-fallback-modules.js";
+import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { consumeAppPageRenderObservationState, discardAppPageRenderState } from "./app-page-render-observation.js";
 import { buildAppPageTags } from "./implicit-tags.js";
 import { resolveAppPageMethodResponse } from "./app-page-method.js";
-import { buildAppPageElement, resolveAppPageIntercept, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams } from "./app-page-request.js";
+import { resolveAppPageInterceptSegmentConfig } from "./app-page-intercept-segment-config.js";
+import { buildAppPageElement, resolveAppPageIntercept, resolveAppPageInterceptState, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams } from "./app-page-request.js";
 import { applyIneligibleRouteCachePolicy, renderAppPageLifecycle } from "./app-page-render.js";
 //#region src/server/app-page-dispatch.ts
 function getActiveLoadingTreePositions(route) {
@@ -146,12 +147,48 @@ function hasNoManifestAdmissionState(routePattern) {
 	}, admission.representation, admission.routePathname) === null;
 }
 async function dispatchAppPage(options) {
-	const dispatch = () => runWithFetchDedupe(() => dispatchAppPageInner(options));
+	const dispatch = () => runWithFetchDedupe(async () => dispatchAppPageInner(await withResolvedIntercept(options)));
 	let response;
 	if (!options.pprFallbackShell || !options.pprRuntime) response = await dispatch();
 	else response = await options.pprRuntime.run(options.pprFallbackShell, dispatch);
 	return options.isRscRequest ? response : traceResponseStart(response);
 }
+/**
+* Resolves the request's intercept once, for the render and its cache reads.
+*
+* Next.js renders an interception as its own route even when its source is the
+* matched route (`app/shots/[id]` beside `app/shots/@modal/(.)[id]`, from
+* `/shots/1` to `/shots/2`). vinext renders that through the matched route's
+* own page render, so the interception's segment config replaces the route's
+* before that render reads it.
+*/
+async function withResolvedIntercept(options) {
+	const interceptState = await resolveAppPageInterceptState({
+		cleanPathname: options.cleanPathname,
+		currentRoute: options.route,
+		findIntercept: options.findIntercept,
+		getSourceRoute: options.getSourceRoute,
+		interceptState: options.interceptState,
+		isRscRequest: options.isRscRequest
+	});
+	if (interceptState.kind !== "current-route") return {
+		...options,
+		interceptState
+	};
+	const config = resolveAppPageInterceptSegmentConfig(options.route, toInterceptOptions(options.interceptionContext, interceptState.intercept));
+	return {
+		...options,
+		interceptState,
+		dynamicConfig: config.dynamicConfig,
+		dynamicStaleTimeSeconds: config.dynamicStaleTimeSeconds,
+		fetchCache: config.fetchCacheMode,
+		hasAnyGenerateStaticParams: config.hasAnyGenerateStaticParams,
+		hasGenerateStaticParams: config.hasGenerateStaticParams,
+		isEdgeRuntime: config.isEdgeRuntime,
+		isStaticGenerationEdgeRuntime: config.isStaticGenerationEdgeRuntime,
+		revalidateSeconds: config.revalidateSeconds
+	};
+}
 async function dispatchAppPageInner(options) {
 	const route = options.route;
 	beginRouteCacheability("app-page", route.pattern);
@@ -206,6 +243,7 @@ async function dispatchAppPageInner(options) {
 			isDynamicError,
 			isForceDynamic,
 			isForceStatic,
+			isPrerender,
 			isProduction: options.isProduction,
 			isProgressiveActionRender: options.isProgressiveActionRender === true,
 			isRscRequest: options.isRscRequest,
@@ -280,6 +318,7 @@ async function dispatchAppPageInner(options) {
 				getSourceRoute(sourceRouteIndex) {
 					return options.getSourceRoute(sourceRouteIndex);
 				},
+				interceptState: options.interceptState,
 				isRscRequest: options.isRscRequest,
 				toInterceptOpts(intercept) {
 					return toInterceptOptions(options.interceptionContext, intercept);
@@ -320,9 +359,10 @@ async function dispatchAppPageInner(options) {
 			isDynamicRscRequest: options.pprRuntime !== void 0 && options.isRscRequest && options.request.headers.get("Next-Router-Prefetch") !== "1" && options.renderedConcreteUrlPaths?.has(options.cleanPathname) !== true,
 			renderFreshPageForCache: async ({ renderDocument }) => {
 				const revalidationTarget = await resolveCacheRenderTarget();
-				const revalidationDynamicConfig = options.resolveRouteDynamicConfig?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? dynamicConfig : void 0);
-				const revalidationConfigRevalidateSeconds = options.resolveRouteRevalidateSeconds?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? currentRevalidateSeconds : null);
-				const revalidationRouteRevalidateSeconds = revalidationTarget.route === route ? void 0 : revalidationConfigRevalidateSeconds ?? (revalidationDynamicConfig === "force-static" || revalidationDynamicConfig === "error" || options.isProduction && options.pprRuntime === void 0 && options.resolveRouteStaticEligible(revalidationTarget.route) ? Infinity : null);
+				const revalidationInterceptConfig = revalidationTarget.interceptOpts ? resolveAppPageInterceptSegmentConfig(revalidationTarget.route, revalidationTarget.interceptOpts) : null;
+				const revalidationDynamicConfig = revalidationInterceptConfig ? revalidationInterceptConfig.dynamicConfig : options.resolveRouteDynamicConfig?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? dynamicConfig : void 0);
+				const revalidationConfigRevalidateSeconds = revalidationInterceptConfig ? revalidationTarget.route === route ? currentRevalidateSeconds : revalidationInterceptConfig.revalidateSeconds : options.resolveRouteRevalidateSeconds?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? currentRevalidateSeconds : null);
+				const revalidationRouteRevalidateSeconds = revalidationTarget.route === route ? void 0 : revalidationConfigRevalidateSeconds ?? (revalidationDynamicConfig === "force-static" || revalidationDynamicConfig === "error" || options.isProduction && options.pprRuntime === void 0 && (revalidationInterceptConfig?.isStaticEligible ?? options.resolveRouteStaticEligible(revalidationTarget.route)) ? Infinity : null);
 				const revalidationRouteHead = {
 					observeSearchParams: revalidationDynamicConfig !== "force-static",
 					searchParams: new URLSearchParams(),
@@ -332,7 +372,7 @@ async function dispatchAppPageInner(options) {
 				return runAppPageRevalidationContext({
 					cleanPathname: options.cleanPathname,
 					displayPathname: options.displayPathname,
-					currentFetchCacheMode: options.resolveRouteFetchCacheMode?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? options.fetchCache ?? null : null),
+					currentFetchCacheMode: revalidationInterceptConfig ? revalidationInterceptConfig.fetchCacheMode : options.resolveRouteFetchCacheMode?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? options.fetchCache ?? null : null),
 					currentFetchRevalidate: revalidationConfigRevalidateSeconds,
 					draftModeSecret: options.draftModeSecret,
 					dynamicConfig: revalidationDynamicConfig,
@@ -459,6 +499,7 @@ async function dispatchAppPageInner(options) {
 				isDynamicError,
 				isForceDynamic,
 				isForceStatic,
+				isPrerender,
 				isProduction: options.isProduction,
 				isProgressiveActionRender: options.isProgressiveActionRender === true,
 				isRscRequest: options.isRscRequest,
@@ -475,9 +516,9 @@ async function dispatchAppPageInner(options) {
 	}
 	const fallbackShellResponse = options.pprRuntime ? await options.pprRuntime.tryServe(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic) : null;
 	if (fallbackShellResponse) return fallbackShellResponse;
-	let interceptDynamicConfig;
-	let interceptDynamicConfigResolved = false;
-	let isInterceptSourceKnownDynamic = false;
+	let interceptConfig = null;
+	let isInterceptKnownDynamic = false;
+	let isInterceptRequestIndependent = false;
 	const renderedRouteHead = {
 		observeSearchParams: !isForceStatic,
 		searchParams: pageSearchParams,
@@ -489,26 +530,27 @@ async function dispatchAppPageInner(options) {
 	};
 	const interceptResult = await resolveAppPageIntercept({
 		async buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams) {
-			const sourceDynamicConfig = interceptDynamicConfigResolved ? interceptDynamicConfig : options.resolveRouteDynamicConfig?.(interceptRoute);
-			if (sourceDynamicConfig === "force-static" || sourceDynamicConfig === "error") {
+			interceptConfig ??= resolveAppPageInterceptSegmentConfig(interceptRoute, interceptOpts);
+			const interceptDynamicConfig = interceptConfig.dynamicConfig;
+			if (interceptDynamicConfig === "force-static" || interceptDynamicConfig === "error") {
 				const { createStaticGenerationHeadersContext } = await import("./app-static-generation.js");
 				setHeadersContext(createStaticGenerationHeadersContext({
 					draftModeEnabled: isDraftMode,
 					draftModeSecret: options.draftModeSecret,
-					dynamicConfig: sourceDynamicConfig,
+					dynamicConfig: interceptDynamicConfig,
 					routeKind: "page",
 					routePattern: interceptRoute.pattern
 				}));
 			} else setHeadersContext(requestHeadersContext);
-			const sourceRevalidateSeconds = options.resolveRouteRevalidateSeconds?.(interceptRoute) ?? null;
-			isInterceptSourceKnownDynamic = sourceDynamicConfig === "force-dynamic" || sourceRevalidateSeconds === 0;
-			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(interceptRoute) ?? null);
-			setCurrentFetchRevalidate(sourceRevalidateSeconds);
-			setCurrentForceDynamicFetchDefault(sourceDynamicConfig === "force-dynamic");
+			isInterceptKnownDynamic = interceptDynamicConfig === "force-dynamic" || interceptConfig.revalidateSeconds === 0;
+			isInterceptRequestIndependent = interceptDynamicConfig === "force-static" || interceptDynamicConfig === "error";
+			setCurrentFetchCacheMode(interceptConfig.fetchCacheMode);
+			setCurrentFetchRevalidate(interceptConfig.revalidateSeconds);
+			setCurrentForceDynamicFetchDefault(interceptDynamicConfig === "force-dynamic");
 			return options.buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, {
-				isForceStatic: sourceDynamicConfig === "force-static",
-				observeMetadataSearchParamsAccess: sourceDynamicConfig !== "force-static",
-				observePageSearchParamsAccess: sourceDynamicConfig !== "force-static",
+				isForceStatic: interceptDynamicConfig === "force-static",
+				observeMetadataSearchParamsAccess: interceptDynamicConfig !== "force-static",
+				observePageSearchParamsAccess: interceptDynamicConfig !== "force-static",
 				isUncacheableRender,
 				serveStreamingMetadata: placeGeneratedMetadataInBody,
 				placeStreamedMetadataInHead: options.renderWholeDocument === true,
@@ -526,18 +568,20 @@ async function dispatchAppPageInner(options) {
 		getSourceRoute(sourceRouteIndex) {
 			return options.getSourceRoute(sourceRouteIndex);
 		},
+		interceptState: options.interceptState,
 		isRscRequest: options.isRscRequest,
 		resolveNavigationParams(sourceRoute, navigationParams, pathname, interceptOpts) {
 			return resolveAppPageNavigationParams(sourceRoute, navigationParams, pathname, interceptOpts);
 		},
-		renderInterceptResponse(sourceRoute, interceptElement) {
+		renderInterceptResponse(sourceRoute, interceptElement, navigationParams) {
 			const interceptOnError = options.createRscOnErrorHandler(options.cleanPathname, sourceRoute.pattern);
 			const interceptStream = options.renderToReadableStream(interceptElement, { onError: interceptOnError });
 			const interceptHeaders = new Headers({
 				"Content-Type": VINEXT_RSC_CONTENT_TYPE,
 				Vary: VINEXT_RSC_VARY_HEADER
 			});
-			if (!(options.pprRuntime !== void 0 || options.resolveRouteStaticEligible(sourceRoute)) || isDraftMode || isInterceptSourceKnownDynamic) interceptHeaders.set("Cache-Control", resolveUncacheableCacheControl(options.isProduction));
+			if (Object.keys(navigationParams).length > 0) interceptHeaders.set(VINEXT_PARAMS_HEADER, encodeURIComponent(JSON.stringify(navigationParams)));
+			if (!(options.pprRuntime !== void 0 || interceptConfig?.isStaticEligible === true) || isDraftMode || isInterceptKnownDynamic || options.isProduction && !isInterceptRequestIndependent) interceptHeaders.set("Cache-Control", resolveUncacheableCacheControl(options.isProduction));
 			mergeMiddlewareResponseHeaders(interceptHeaders, options.middlewareContext.headers);
 			applyRscCompatibilityIdHeader(interceptHeaders);
 			applyRscDeploymentIdHeader(interceptHeaders);
@@ -546,11 +590,10 @@ async function dispatchAppPageInner(options) {
 				headers: interceptHeaders
 			});
 		},
-		async resolveSearchParams(sourceRoute, searchParams) {
+		async resolveSearchParams(sourceRoute, searchParams, interceptOpts) {
 			await options.ensureRouteLoaded?.(sourceRoute);
-			interceptDynamicConfig = options.resolveRouteDynamicConfig?.(sourceRoute);
-			interceptDynamicConfigResolved = true;
-			return interceptDynamicConfig === "force-static" ? new URLSearchParams() : searchParams;
+			interceptConfig = resolveAppPageInterceptSegmentConfig(sourceRoute, interceptOpts);
+			return interceptConfig.dynamicConfig === "force-static" ? new URLSearchParams() : searchParams;
 		},
 		searchParams: options.searchParams,
 		setNavigationContext: options.setNavigationContext,