vinext 0.2.0 → 0.2.1

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

@@ -13,19 +13,20 @@ import { DevRecoveryBoundary, GlobalErrorBoundary, RedirectBoundary } from "../s
 import { beginAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { AppRouterScrollCommitProvider } from "../shims/app-router-scroll.js";
 import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
-import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, getVinextRscCompatibilityId, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { getNavigationRuntime, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import "../client/instrumentation-client.js";
-import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap } from "./app-bfcache-identity.js";
-import { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, resolveServerActionOperationLane } from "./app-browser-action-result.js";
-import { createClientReuseManifestHeaderFromVisibleAppState } from "./app-browser-client-reuse-manifest.js";
 import { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext } from "./app-browser-interception-context.js";
 import { readHistoryStatePreviousNextUrl } from "./app-history-state.js";
 import { AppBrowserMpaNavigationScheduler } from "./app-browser-mpa-navigation.js";
 import { blockDangerousStreamedRscRedirect } from "./app-browser-rsc-redirect.js";
 import { navigationPlanner } from "./navigation-planner.js";
-import { DYNAMIC_NAVIGATION_CACHE_TTL, PREFETCH_CACHE_TTL, __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, deletePrefetchResponseSnapshot, getClientNavigationRenderContext, getPrefetchCache, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, seedPrefetchResponseSnapshot, setClientParams, setMountedSlotsHeader, setPendingPathname, useRouter } from "../shims/navigation.js";
+import { resolveHybridClientRewriteHref } from "../shims/internal/hybrid-client-route-owner.js";
+import { DYNAMIC_NAVIGATION_CACHE_TTL, PREFETCH_CACHE_TTL, __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, deletePrefetchResponseSnapshot, getClientNavigationRenderContext, getMountedSlotsHeader, getPrefetchCache, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, seedPrefetchResponseSnapshot, setClientParams, setMountedSlotsHeader, setPendingPathname, useRouter } from "../shims/navigation.js";
+import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap } from "./app-bfcache-identity.js";
+import { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, resolveServerActionOperationLane } from "./app-browser-action-result.js";
+import { createClientReuseManifestHeaderFromVisibleAppState } from "./app-browser-client-reuse-manifest.js";
 import { chunksToReadableStream, createProgressiveRscStream, getVinextBrowserGlobal } from "./app-browser-stream.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 } from "./app-browser-navigation-controller.js";
@@ -193,6 +194,21 @@ function clearClientNavigationCaches() {
 	clearPrefetchState();
 	historyController.invalidateRestorableClientState();
 }
+function normalizeBrowserRscUrlForReuse(url) {
+	if (!url) return null;
+	try {
+		const parsed = new URL(url, window.location.origin);
+		stripRscCacheBustingSearchParam(parsed);
+		return `${parsed.pathname}${parsed.search}`;
+	} catch {
+		return null;
+	}
+}
+function isAlternatePrefetchResponseUrl(responseUrl, additionalRscUrls) {
+	const normalizedResponseUrl = normalizeBrowserRscUrlForReuse(responseUrl);
+	if (normalizedResponseUrl === null) return false;
+	return additionalRscUrls.some((additionalRscUrl) => normalizeBrowserRscUrlForReuse(additionalRscUrl) === normalizedResponseUrl);
+}
 function isSettledPrefetchCacheEntry(entry) {
 	return entry.outcome === "cache-seeded" && entry.pending === void 0 && entry.snapshot !== void 0;
 }
@@ -242,6 +258,7 @@ async function learnOptimisticRouteTemplatesFromPrefetchCache(options) {
 		if (optimisticRouteTemplateSources.has(sourceKey)) continue;
 		if (optimisticRouteTemplateLearning.has(sourceKey)) continue;
 		if (!isSettledPrefetchCacheEntry(entry)) continue;
+		if (entry.prefetchKind === "route-tree") continue;
 		const promise = learnOptimisticRouteTemplateFromPrefetch({
 			cacheKey,
 			entry,
@@ -545,9 +562,17 @@ function BrowserRoot({ hydrationCachePublication, initialElements, initialNaviga
 		setWindowNextInternalSourcePage(AppElementsWire.readMetadata(treeState.elements).sourcePage);
 	}, [treeState.elements]);
 	useLayoutEffect(() => {
-		setMountedSlotsHeader(getMountedSlotIdsHeader(stateRef.current.elements));
+		const previousMountedSlotsHeader = getMountedSlotsHeader();
+		const nextMountedSlotsHeader = getMountedSlotIdsHeader(stateRef.current.elements);
+		setMountedSlotsHeader(nextMountedSlotsHeader);
 		removeStylesheetLinksCoveredByInlineCss();
-		getNavigationRuntime()?.functions.pingVisibleLinks?.();
+		if (previousMountedSlotsHeader === nextMountedSlotsHeader) return;
+		const pingTimer = window.setTimeout(() => {
+			getNavigationRuntime()?.functions.pingVisibleLinks?.();
+		}, 0);
+		return () => {
+			window.clearTimeout(pingTimer);
+		};
 	}, [treeState.elements]);
 	useLayoutEffect(() => {
 		if (treeState.renderId !== 0) return;
@@ -748,14 +773,14 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 			...initialRscBootstrap?.dynamicStaleTimeSeconds !== void 0 ? { dynamicStaleTimeSeconds: initialRscBootstrap.dynamicStaleTimeSeconds } : {},
 			mountedSlotsHeader,
 			paramsHeader: encodeURIComponent(JSON.stringify(initialParams)),
+			renderedPathAndSearch: null,
 			url: rscUrl
 		};
 		const fallbackTtlMs = initialRscBootstrap?.initialCacheKind === "static" ? PREFETCH_CACHE_TTL : DYNAMIC_NAVIGATION_CACHE_TTL;
 		hydrationCachePublication.publish(() => {
 			if (cacheGeneration !== clientNavigationCacheGeneration) return () => {};
 			if (isCacheRestorableAppPayloadMetadata(metadata)) return storeVisitedResponseSnapshot(rscUrl, metadata.interceptionContext, snapshot, initialParams, fallbackTtlMs, mountedSlotsHeader);
-			seedPrefetchResponseSnapshot(rscUrl, snapshot, metadata.interceptionContext, mountedSlotsHeader, fallbackTtlMs);
-			return () => deletePrefetchResponseSnapshot(rscUrl, snapshot, metadata.interceptionContext);
+			return storeVisitedResponseSnapshot(rscUrl, metadata.interceptionContext, snapshot, initialParams, fallbackTtlMs, mountedSlotsHeader, elements);
 		});
 	}).catch(() => {});
 	historyController.writeBootstrapHistoryMetadata();
@@ -867,6 +892,8 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						renderMode: navigationKind === "refresh" ? APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI : void 0
 					});
 					const rscUrl = await createRscRequestUrl(url.pathname + url.search, requestHeaders);
+					const rewrittenNavigationHref = navigationKind === "navigate" ? resolveHybridClientRewriteHref(currentHref, __basePath) : null;
+					const additionalPrefetchRscUrls = rewrittenNavigationHref && rewrittenNavigationHref !== currentHref ? [await createRscRequestUrl(rewrittenNavigationHref, requestHeaders)] : [];
 					const visitedResponseCandidate = shouldBypassNavigationCache ? {
 						cacheKey: AppElementsWire.encodeCacheKey(rscUrl, requestInterceptionContext),
 						entry: null,
@@ -883,7 +910,10 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						visitedResponse
 					});
 					let routeManifest = navigationKind === "navigate" ? getBrowserRouteManifest() : null;
-					const hasPrefetchCandidate = prefetchProbeDecision.kind === "probe" && hasPrefetchCacheEntryForNavigation(rscUrl, requestInterceptionContext, mountedSlotsHeader, { notifyInvalidation: false });
+					const hasPrefetchCandidate = prefetchProbeDecision.kind === "probe" && hasPrefetchCacheEntryForNavigation(rscUrl, requestInterceptionContext, mountedSlotsHeader, {
+						additionalRscUrls: additionalPrefetchRscUrls,
+						notifyInvalidation: false
+					});
 					const reuseDecision = navigationPlanner.classifyNavigationReuse({
 						bypassNavigationCache: shouldBypassNavigationCache,
 						navigationKind,
@@ -941,12 +971,15 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					let navResponseUrl = null;
 					let fallbackReuseDecision = reuseDecision;
 					if (reuseDecision.kind === "consumePrefetch") {
-						const prefetchedResponse = await consumePrefetchResponseForNavigation(rscUrl, requestInterceptionContext, mountedSlotsHeader, { shouldConsume: () => browserNavigationController.isCurrentNavigation(navId) });
+						const prefetchedResponse = await consumePrefetchResponseForNavigation(rscUrl, requestInterceptionContext, mountedSlotsHeader, {
+							additionalRscUrls: additionalPrefetchRscUrls,
+							shouldConsume: () => browserNavigationController.isCurrentNavigation(navId)
+						});
 						if (!browserNavigationController.isCurrentNavigation(navId)) return;
 						if (prefetchedResponse) {
 							navResponse = restoreRscResponse(prefetchedResponse, false);
 							navResponseExpiresAt = prefetchedResponse.expiresAt;
-							navResponseUrl = prefetchedResponse.url;
+							navResponseUrl = isAlternatePrefetchResponseUrl(prefetchedResponse.url, additionalPrefetchRscUrls) ? rscUrl : prefetchedResponse.url;
 						}
 						if (!navResponse) {
 							routeManifest = navigationKind === "navigate" ? getBrowserRouteManifest() : null;
@@ -1053,7 +1086,6 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						committedState = state;
 						if (activeNavigationAbortController === navigationAbortController) activeNavigationAbortController = null;
 					}, detachedNavigationCommits ? "authoritative" : void 0) !== "committed") return;
-					if (!browserNavigationController.isCurrentNavigation(navId)) return;
 					try {
 						const renderedElements = await rscPayload;
 						if (navigationCacheGeneration !== clientNavigationCacheGeneration) return;
@@ -1074,7 +1106,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						if (isCacheRestorableAppPayloadMetadata(metadata)) {
 							if (navigationCacheGeneration !== clientNavigationCacheGeneration) return;
 							storeVisitedResponseSnapshot(rscUrl, interceptionContext, snapshot, navParams, PREFETCH_CACHE_TTL, mountedSlotsHeader);
-						} else if (committedState !== null && getMountedSlotIdsHeader(committedState.elements) === null) {
+						} else if (committedState !== null) {
 							const state = committedState;
 							const committedElements = {
 								...state.elements,

package/dist/server/app-browser-navigation-controller.js

@@ -1,8 +1,8 @@
 import { stripBasePath } from "../utils/base-path.js";
 import { clearAppNavigationFailureTarget, getAppNavigationFailureTarget } from "../client/app-nav-failure-handler.js";
 import { claimAppRouterScrollIntentForCommit, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
-import { resolveServerActionOperationLane, shouldScheduleRefreshForDiscardedServerAction } from "./app-browser-action-result.js";
 import { activateNavigationSnapshot, clearPendingPathname, commitClientNavigationState, createSnapshotPathAndSearch } from "../shims/navigation.js";
+import { resolveServerActionOperationLane, shouldScheduleRefreshForDiscardedServerAction } from "./app-browser-action-result.js";
 import { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, createPendingNavigationCommit } from "./app-browser-state.js";
 import { applyApprovedVisibleCommit, approveHmrVisibleCommit, approvePendingNavigationCommit, resolveAndClassifyNavigationCommit } from "./app-browser-visible-commit.js";
 import { startTransition, useInsertionEffect, useLayoutEffect } from "react";

package/dist/server/app-browser-server-action-client.js

@@ -1,3 +1,4 @@
+import { hasBasePath } from "../utils/base-path.js";
 import { ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER } from "./headers.js";
 import { DANGEROUS_URL_BLOCK_MESSAGE, isDangerousScheme } from "../shims/url-safety.js";
 import { AppElementsWire } from "./app-elements-wire.js";
@@ -9,7 +10,7 @@ import { applyServerActionResultDecision } from "./app-browser-server-action-nav
 import { throwOnServerActionNotFound } from "./server-action-not-found.js";
 import { createFromFetch, createTemporaryReferenceSet, encodeReply } from "@vitejs/plugin-rsc/browser";
 //#region src/server/app-browser-server-action-client.ts
-function resolveActionRedirectTarget(response, performHardNavigation) {
+function resolveActionRedirectTarget(response, basePath, performHardNavigation) {
 	const actionRedirect = response.headers.get(ACTION_REDIRECT_HEADER);
 	if (!actionRedirect) return null;
 	if (isDangerousScheme(actionRedirect)) {
@@ -25,7 +26,7 @@ function resolveActionRedirectTarget(response, performHardNavigation) {
 			if (!baseDir.endsWith("/")) baseDir += "/";
 			redirectUrl = new URL(actionRedirect, `${baseParsed.origin}${baseDir}${baseParsed.search}`);
 		}
-		if (redirectUrl.origin !== window.location.origin) {
+		if (redirectUrl.origin !== window.location.origin || basePath !== "" && !hasBasePath(redirectUrl.pathname, basePath)) {
 			performHardNavigation(actionRedirect);
 			return null;
 		}
@@ -60,6 +61,7 @@ async function invokeClientServerAction(id, args, actionInitiation, deps) {
 		actionId: id,
 		basePath: deps.basePath,
 		elements: actionInitiation.routerState.elements,
+		interceptionContext: actionInitiation.routerState.interception !== null ? actionInitiation.routerState.interceptionContext : null,
 		previousNextUrl: actionInitiation.routerState.previousNextUrl
 	}).headers;
 	const fetchResponse = await fetch(createServerActionRequestUrl(actionInitiation.path), {
@@ -69,7 +71,7 @@ async function invokeClientServerAction(id, args, actionInitiation, deps) {
 	});
 	throwOnServerActionNotFound(fetchResponse, id);
 	const hasActionRedirect = fetchResponse.headers.has(ACTION_REDIRECT_HEADER);
-	const actionRedirectTarget = resolveActionRedirectTarget(fetchResponse, (url, historyMode) => deps.performHardNavigation(url, historyMode));
+	const actionRedirectTarget = resolveActionRedirectTarget(fetchResponse, deps.basePath, (url, historyMode) => deps.performHardNavigation(url, historyMode));
 	if (hasActionRedirect && !actionRedirectTarget) return void 0;
 	const actionResultFacts = createServerActionResultFacts({
 		actionRedirectHref: actionRedirectTarget?.href ?? null,

package/dist/server/app-browser-state.d.ts

@@ -107,6 +107,7 @@ type ResolveServerActionRequestStateOptions = {
   actionId: string;
   basePath: string;
   elements: AppElements;
+  interceptionContext?: string | null;
   previousNextUrl: string | null;
 };
 type ResolveServerActionRequestStateResult = {

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

@@ -6,12 +6,12 @@ import { AppElementsWire } from "./app-elements-wire.js";
 import { getMountedSlotIds, getMountedSlotIdsHeader } from "./app-elements.js";
 import { createRscRequestHeaders } from "./app-rsc-cache-busting.js";
 import { createCacheEntryReuseProof } from "./cache-proof.js";
-import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
 import { createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
 import { NavigationTraceReasonCodes, createNavigationLifecycleTraceFields, createNavigationTrace } from "./navigation-trace.js";
 import { verifyOperationTokenForCommit } from "./operation-token.js";
 import { navigationPlanner, resolveDefaultOrUnmatchedSlotPersistenceForLayouts } from "./navigation-planner.js";
 import { createSnapshotPathAndSearch } from "../shims/navigation.js";
+import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
 //#region src/server/app-browser-state.ts
 const COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN = { origin: "committed-cache" };
 const FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN = { origin: "fresh" };
@@ -68,7 +68,7 @@ function resolveServerActionRequestState(options) {
 	const headers = createRscRequestHeaders();
 	headers.set(RSC_ACTION_HEADER, options.actionId);
 	headers.set(NEXT_ACTION_HEADER, options.actionId);
-	const interceptionContext = resolveInterceptionContextFromPreviousNextUrl(options.previousNextUrl, options.basePath);
+	const interceptionContext = resolveInterceptionContextFromPreviousNextUrl(options.previousNextUrl, options.basePath) ?? options.interceptionContext ?? null;
 	if (interceptionContext !== null) headers.set(VINEXT_INTERCEPTION_CONTEXT_HEADER, interceptionContext);
 	const mountedSlotsHeader = getMountedSlotIdsHeader(options.elements);
 	if (mountedSlotsHeader !== null) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, mountedSlotsHeader);

package/dist/server/app-browser-visible-commit.js

@@ -1,8 +1,8 @@
 import { normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { mergeElements } from "../shims/slot.js";
-import { preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
 import { NavigationTraceReasonCodes, NavigationTraceTransactionCodes, createNavigationTrace, prependNavigationTraceEntry } from "./navigation-trace.js";
+import { preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
 import { createPendingNavigationCommit, resolvePendingNavigationCommitDispositionDecision } from "./app-browser-state.js";
 //#region src/server/app-browser-visible-commit.ts
 const approvedVisibleCommitBrand = Symbol("ApprovedVisibleCommit");

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

@@ -1,6 +1,6 @@
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
 import { resolveAppPageSegmentParams } from "./app-page-params.js";
-import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 //#region src/server/app-page-boundary.ts
@@ -109,6 +109,7 @@ async function renderAppPageBoundaryResponse(options) {
 		applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
 		mergeMiddlewareResponseHeaders(headers, options.middlewareHeaders ?? null);
 		applyRscCompatibilityIdHeader(headers);
+		applyRscDeploymentIdHeader(headers);
 		return new Response(rscStream, {
 			status: options.status,
 			headers

package/dist/server/app-page-cache-finalizer.d.ts

@@ -50,6 +50,7 @@ type ScheduleAppPageRscCacheWriteOptions = {
   isrSet: AppPageCacheSetter;
   interceptionContext?: string | null;
   mountedSlotsHeader?: string | null;
+  omitPendingDynamicCacheState?: boolean;
   renderMode?: AppRscRenderMode;
   preserveClientResponseHeaders?: boolean;
   expireSeconds?: number;

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

@@ -83,7 +83,7 @@ function finalizeAppPageRscCacheResponse(response, options) {
 	if (!scheduleAppPageRscCacheWrite(options)) return response;
 	if (options.preserveClientResponseHeaders === true) return response;
 	const clientHeaders = new Headers(response.headers);
-	applyPendingDynamicCdnHeaders(clientHeaders, options.getPageTags());
+	applyPendingDynamicCdnHeaders(clientHeaders, options.getPageTags(), { omitCacheState: options.omitPendingDynamicCacheState === true });
 	return new Response(response.body, {
 		status: response.status,
 		statusText: response.statusText,
@@ -92,8 +92,8 @@ function finalizeAppPageRscCacheResponse(response, options) {
 }
 function scheduleAppPageRscCacheWrite(options) {
 	const capturedRscDataPromise = options.capturedRscDataPromise;
-	if (!capturedRscDataPromise || options.dynamicUsedDuringBuild) return false;
-	const rscKey = options.isrRscKey(options.cleanPathname, options.mountedSlotsHeader, options.renderMode, options.interceptionContext);
+	if (!capturedRscDataPromise || options.dynamicUsedDuringBuild || options.mountedSlotsHeader) return false;
+	const rscKey = options.isrRscKey(options.cleanPathname, null, options.renderMode, options.interceptionContext);
 	const cachePromise = (async () => {
 		try {
 			const rscData = await capturedRscDataPromise;

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

@@ -4,7 +4,7 @@ import { applyCdnResponseHeaders } from "./cache-control.js";
 import { decideIsr } from "./isr-decision.js";
 import { buildAppPageCacheValue } from "./isr-cache.js";
 import { encodeCacheTag } from "../utils/encode-cache-tag.js";
-import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { hasCompleteNegativeRequestApiProof } from "./cache-proof.js";
@@ -55,6 +55,15 @@ function getCachedAppPageValue(entry) {
 function hasQueryInvariantAppPageProof(cachedValue) {
 	return cachedValue.renderObservation !== void 0 && hasCompleteNegativeRequestApiProof(cachedValue.renderObservation, ["searchParams"]);
 }
+function resolveRegeneratedAppPageCachePolicy(options) {
+	let revalidateSeconds = options.routeRevalidateSeconds;
+	const renderRevalidateSeconds = options.renderCacheControl?.revalidate;
+	if (renderRevalidateSeconds !== void 0) revalidateSeconds = revalidateSeconds > 0 ? Math.min(revalidateSeconds, renderRevalidateSeconds) : renderRevalidateSeconds;
+	return {
+		expireSeconds: options.renderCacheControl?.expire ?? options.expireSeconds,
+		revalidateSeconds
+	};
+}
 function buildAppPageCachedResponse(cachedValue, options) {
 	const status = options.middlewareStatus ?? (cachedValue.status || 200);
 	const { cacheControl } = decideIsr({
@@ -75,6 +84,7 @@ function buildAppPageCachedResponse(cachedValue, options) {
 			mountedSlotsHeader: options.mountedSlotsHeader
 		});
 		applyRscCompatibilityIdHeader(rscHeaders);
+		applyRscDeploymentIdHeader(rscHeaders);
 		return new Response(cachedValue.rscData, {
 			status,
 			headers: rscHeaders
@@ -118,7 +128,11 @@ async function serveAppPageCachedHtml(options, transformValue) {
 	return response;
 }
 async function readAppPageCacheResponse(options) {
-	const isrKey = options.isRscRequest ? options.isrRscKey(options.cleanPathname, options.mountedSlotsHeader, options.renderMode, options.interceptionContext) : options.isrHtmlKey(options.cleanPathname);
+	if (options.isRscRequest && options.mountedSlotsHeader) {
+		options.isrDebug?.("MISS (mounted slots RSC variant)", options.cleanPathname);
+		return null;
+	}
+	const isrKey = options.isRscRequest ? options.isrRscKey(options.cleanPathname, null, options.renderMode, options.interceptionContext) : options.isrHtmlKey(options.cleanPathname);
 	const artifact = options.isRscRequest ? "rsc" : "html";
 	try {
 		const cached = await options.isrGet(isrKey);
@@ -177,10 +191,13 @@ async function readAppPageCacheResponse(options) {
 		if (cached?.isStale && cachedValue) {
 			options.scheduleBackgroundRegeneration(isrKey, async () => {
 				const revalidatedPage = await options.renderFreshPageForCache();
-				const revalidateSeconds = revalidatedPage.cacheControl?.revalidate ?? options.revalidateSeconds;
-				const expireSeconds = revalidatedPage.cacheControl?.expire ?? options.expireSeconds;
-				const writes = [options.isrSet(options.isRscRequest ? isrKey : options.isrRscKey(options.cleanPathname, options.mountedSlotsHeader, options.renderMode, options.interceptionContext), buildAppPageCacheValue("", revalidatedPage.rscData, 200, revalidatedPage.rscRenderObservation), revalidateSeconds, revalidatedPage.tags, expireSeconds)];
-				if (!options.isRscRequest) writes.push(options.isrSet(isrKey, buildAppPageCacheValue(revalidatedPage.html, void 0, 200, revalidatedPage.htmlRenderObservation, revalidatedPage.linkHeader ? { link: revalidatedPage.linkHeader } : void 0), revalidateSeconds, revalidatedPage.tags, expireSeconds));
+				const cachePolicy = resolveRegeneratedAppPageCachePolicy({
+					expireSeconds: options.expireSeconds,
+					renderCacheControl: revalidatedPage.cacheControl,
+					routeRevalidateSeconds: options.revalidateSeconds
+				});
+				const writes = [options.isrSet(options.isRscRequest ? isrKey : options.isrRscKey(options.cleanPathname, null, options.renderMode, options.interceptionContext), buildAppPageCacheValue("", revalidatedPage.rscData, 200, revalidatedPage.rscRenderObservation), cachePolicy.revalidateSeconds, revalidatedPage.tags, cachePolicy.expireSeconds)];
+				if (!options.isRscRequest) writes.push(options.isrSet(isrKey, buildAppPageCacheValue(revalidatedPage.html, void 0, 200, revalidatedPage.htmlRenderObservation, revalidatedPage.linkHeader ? { link: revalidatedPage.linkHeader } : void 0), cachePolicy.revalidateSeconds, revalidatedPage.tags, cachePolicy.expireSeconds));
 				await Promise.all(writes);
 				options.isrDebug?.("regen complete", options.cleanPathname);
 			});

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

@@ -199,6 +199,7 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   }>;
   request: Request;
   revalidateSeconds: number | null;
+  renderedPathAndSearch?: string | null;
   resolveRouteFetchCacheMode?: (route: TRoute) => FetchCacheMode | null;
   resolveRouteDynamicConfig?: (route: TRoute) => string | null | undefined;
   rootForbiddenModule?: AppPageModule | null;

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

@@ -1,12 +1,13 @@
 import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
+import "../utils/protocol-headers.js";
 import { AppElementsWire } from "./app-elements-wire.js";
-import { shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
+import { APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
 import "./app-elements.js";
 import { consumeDynamicUsage, consumeInvalidDynamicUsageError, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersContext, isDraftModeRequest, markDynamicUsage, peekDynamicUsage, peekRenderRequestApiUsage, setHeadersContext } from "../shims/headers.js";
 import { _consumeRequestScopedCacheLife, _peekRequestScopedCacheLife } from "../shims/cache-request-state.js";
-import { ensureFetchPatch, getCollectedFetchTags, peekDynamicFetchObservations, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
-import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
+import { ensureFetchPatch, getCollectedFetchTags, peekDynamicFetchObservations, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground } from "../shims/fetch-cache.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import "./app-page-response.js";
 import { buildAppPageSpecialErrorResponse, probeAppPageThrownError, resolveAppPageSpecialError } from "./app-page-execution.js";
@@ -100,6 +101,10 @@ function getEffectiveLayoutClassifications(route, debugClassification) {
 function shouldReadAppPageCache(options) {
 	return options.isProduction && !options.isProgressiveActionRender && !options.isDraftMode && !options.isForceDynamic && (options.isRscRequest || !options.scriptNonce) && (options.revalidateSeconds === null || options.revalidateSeconds > 0);
 }
+function resolveAppPageCacheReadRevalidateSeconds(options) {
+	if (options.revalidateSeconds === null && (options.isForceStatic || options.isDynamicError)) return Infinity;
+	return options.revalidateSeconds ?? 0;
+}
 function hasSearchParams(searchParams) {
 	return searchParams !== null && searchParams !== void 0 && searchParams.size > 0;
 }
@@ -119,6 +124,7 @@ async function runAppPageRevalidationContext(options, renderFn) {
 		unstableCacheRevalidation: "foreground"
 	}), async () => {
 		ensureFetchPatch();
+		setRefreshStaleFetchesInForeground(process.env.VINEXT_PRERENDER === "1");
 		setCurrentFetchSoftTags(buildAppPageTags(options.cleanPathname, [], options.routeSegments));
 		options.setNavigationContext({
 			pathname: options.displayPathname ?? options.cleanPathname,
@@ -154,10 +160,12 @@ async function dispatchAppPageInner(options) {
 	const isForceStatic = dynamicConfig === "force-static";
 	const isDynamicError = dynamicConfig === "error";
 	const isForceDynamic = dynamicConfig === "force-dynamic";
+	const isPrefetchDynamicShell = options.renderMode === APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL;
 	const isDraftMode = isDraftModeRequest(options.request, options.draftModeSecret);
 	const requestHeadersContext = getHeadersContext();
-	const hasRequestSearchParams = !isForceStatic && hasSearchParams(options.searchParams);
-	const pageSearchParams = isForceStatic ? new URLSearchParams() : options.searchParams;
+	const shouldUseEmptySearchParams = isForceStatic || isPrefetchDynamicShell;
+	const hasRequestSearchParams = !shouldUseEmptySearchParams && hasSearchParams(options.searchParams);
+	const pageSearchParams = shouldUseEmptySearchParams ? new URLSearchParams() : options.searchParams;
 	const layoutParamAccess = createAppLayoutParamAccessTracker();
 	const hasActiveLoadingBoundary = shouldSuppressLoadingBoundaries(options.renderMode ?? "navigation") ? false : Boolean(route.loading?.default);
 	setCurrentFetchSoftTags(buildAppPageTags(options.cleanPathname, [], route.routeSegments));
@@ -222,7 +230,11 @@ async function dispatchAppPageInner(options) {
 			mountedSlotsHeader: options.mountedSlotsHeader,
 			renderMode: options.renderMode,
 			expireSeconds: options.expireSeconds,
-			revalidateSeconds: currentRevalidateSeconds ?? 0,
+			revalidateSeconds: resolveAppPageCacheReadRevalidateSeconds({
+				isDynamicError,
+				isForceStatic,
+				revalidateSeconds: currentRevalidateSeconds
+			}),
 			renderFreshPageForCache: async () => {
 				const revalidationTarget = await resolveAppPageInterceptionRerenderTarget({
 					cleanPathname: options.cleanPathname,
@@ -361,6 +373,7 @@ async function dispatchAppPageInner(options) {
 			});
 			mergeMiddlewareResponseHeaders(interceptHeaders, options.middlewareContext.headers);
 			applyRscCompatibilityIdHeader(interceptHeaders);
+			applyRscDeploymentIdHeader(interceptHeaders);
 			return new Response(interceptStream, {
 				status: options.middlewareContext.status ?? 200,
 				headers: interceptHeaders
@@ -428,6 +441,8 @@ async function dispatchAppPageInner(options) {
 	const activeFallbackShellState = options.pprRuntime?.getState() ?? null;
 	const pprFallbackShellSignal = activeFallbackShellState?.abortController.signal;
 	const pprFallbackShellReactSignal = activeFallbackShellState?.reactAbortController.signal;
+	const isPrerender = process.env.VINEXT_PRERENDER === "1";
+	const isSpeculativePrerender = isPrerender && options.request.headers.get("x-vinext-prerender-speculative") === "1";
 	return renderAppPageLifecycle({
 		basePath: options.basePath,
 		clientTraceMetadata: options.clientTraceMetadata,
@@ -459,7 +474,7 @@ async function dispatchAppPageInner(options) {
 		},
 		handlerStart: options.handlerStart,
 		hasLoadingBoundary: hasActiveLoadingBoundary,
-		omitPendingDynamicCacheState: !options.isRscRequest && hasRequestSearchParams,
+		omitPendingDynamicCacheState: hasRequestSearchParams,
 		formState: options.formState ?? null,
 		isProgressiveActionRender: options.isProgressiveActionRender === true,
 		isDynamicError,
@@ -467,7 +482,8 @@ async function dispatchAppPageInner(options) {
 		isForceDynamic,
 		isForceStatic,
 		isEdgeRuntime: options.isEdgeRuntime === true,
-		isPrerender: process.env.VINEXT_PRERENDER === "1",
+		isPrerender,
+		isSpeculativePrerender,
 		isProduction: options.isProduction,
 		isRscRequest: options.isRscRequest,
 		isrDebug: options.isrDebug,
@@ -483,6 +499,7 @@ async function dispatchAppPageInner(options) {
 		params: options.params,
 		pprFallbackShellSignal,
 		pprFallbackShellReactSignal,
+		renderedPathAndSearch: options.renderedPathAndSearch,
 		abortPprFallbackShell: activeFallbackShellState ? () => {
 			options.pprRuntime.beginFinalRender(activeFallbackShellState);
 		} : void 0,

package/dist/server/app-page-element-builder.js

@@ -51,6 +51,7 @@ async function buildPageElements(options) {
 	const hasPageModule = !!pageModule;
 	const renderIdentity = createAppPageRenderIdentity({
 		displayPathname,
+		matchedRoutePathname: routePath,
 		targetMatchedPathname: routePath,
 		interceptionContext: opts?.interceptionContext ?? null,
 		interceptSourceMatchedUrl: opts?.interceptSourceMatchedUrl ?? null,

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

@@ -1,7 +1,7 @@
 import { addBasePathToPathname } from "../utils/base-path.js";
 import { VINEXT_RSC_REDIRECT_HEADER } from "./headers.js";
 import { runWithConnectionProbe } from "../shims/headers.js";
-import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, createRscRedirectLocation } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, createRscRedirectLocation } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
@@ -161,6 +161,7 @@ async function buildAppPageSpecialErrorResponse(options) {
 			});
 			applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
 			applyRscCompatibilityIdHeader(headers);
+			applyRscDeploymentIdHeader(headers);
 			mergeMiddlewareResponseHeaders(headers, options.middlewareContext?.headers ?? null);
 			const pendingCookies = options.getAndClearPendingCookies?.() ?? [];
 			for (const cookie of pendingCookies) headers.append("Set-Cookie", cookie);

package/dist/server/app-page-render-identity.d.ts

@@ -2,6 +2,7 @@ import { AppElementsInterception } from "./app-elements-wire.js";
 //#region src/server/app-page-render-identity.d.ts
 type AppPageRenderIdentityInput = {
   displayPathname: string;
+  matchedRoutePathname?: string;
   targetMatchedPathname?: string;
   interceptionContext?: string | null;
   interceptSourceMatchedUrl?: string | null;

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

@@ -14,9 +14,10 @@ function normalizeAppPageInterceptionProofPathname(pathname) {
 function createAppPageRenderIdentity(input) {
 	const interceptionContext = input.interceptionContext ?? null;
 	const targetMatchedPathname = normalizeAppPageRenderMatchedPathname(input.targetMatchedPathname ?? input.displayPathname);
+	const requestedMatchedRoutePathname = normalizeAppPageRenderMatchedPathname(input.matchedRoutePathname ?? input.targetMatchedPathname ?? input.displayPathname);
 	const sourceMatchedPathname = normalizeAppPageInterceptionProofPathname(input.interceptSourceMatchedUrl ?? null);
 	const slotId = input.interceptSlotId ?? null;
-	const matchedRoutePathname = sourceMatchedPathname ?? targetMatchedPathname;
+	const matchedRoutePathname = sourceMatchedPathname ?? requestedMatchedRoutePathname;
 	const routeId = AppElementsWire.encodeRouteId(matchedRoutePathname, null);
 	const pageId = AppElementsWire.encodePageId(matchedRoutePathname, null);
 	const interception = sourceMatchedPathname === null || slotId === null ? null : {

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

@@ -60,6 +60,7 @@ type RenderAppPageLifecycleOptions = {
   isForceStatic: boolean;
   isProgressiveActionRender?: boolean;
   isPrerender?: boolean;
+  isSpeculativePrerender?: boolean;
   isProduction: boolean;
   probePageBeforeRender?: boolean;
   omitPendingDynamicCacheState?: boolean;
@@ -103,6 +104,7 @@ type RenderAppPageLifecycleOptions = {
   clientReuseManifest?: ClientReuseManifestParseResult;
   skipDisposition?: ClientReuseManifestSkipDisposition;
   mountedSlotsHeader?: string | null;
+  renderedPathAndSearch?: string | null;
   renderMode?: AppRscRenderMode;
   waitUntil?: (promise: Promise<void>) => void;
   layoutParamAccess?: AppLayoutParamAccessTracker;