vinext 1.0.0-beta.2 → 1.0.0-beta.4

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

@@ -12,7 +12,7 @@ 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, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, getVinextRscCompatibilityId } 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";
@@ -24,17 +24,18 @@ 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, getMountedSlotsHeader, getPrefetchCache, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, preloadHybridClientRouteOwner, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveLoadedHybridClientRewriteHref, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, seedPrefetchResponseSnapshot, setClientParams, setMountedSlotsHeader, setPendingPathname, useRouter } from "../shims/navigation.js";
+import { DYNAMIC_NAVIGATION_CACHE_TTL, PREFETCH_CACHE_TTL, __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponse, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, deletePrefetchResponseSnapshot, getClientNavigationRenderContext, getMountedSlotsHeader, getPrefetchCache, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, preloadHybridClientRouteOwner, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveLoadedHybridClientRewriteHref, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, seedPrefetchResponseSnapshot, setClientParams, setMountedSlotsHeader, setPendingPathname, useRouter } from "../shims/navigation.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";
 import { consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition } from "./app-browser-hydration.js";
 import { AppBrowserHistoryController } from "./app-browser-history-controller.js";
-import { createVisitedResponseCacheEntry, isVisitedResponseCacheEntryFresh } from "./app-visited-response-cache.js";
+import { createVisitedResponseCacheEntry, deleteVisitedResponseCacheEntry, findVisitedResponseCacheEntry, isVisitedResponseCacheEntryFresh } from "./app-visited-response-cache.js";
 import { createPopstateRestoreHandler, restoreSynchronousPopstateScrollPosition } from "./app-browser-popstate.js";
 import { createDevOnCaughtError, createOnUncaughtError, createProdOnCaughtError, prodOnRecoverableError } from "./app-browser-error.js";
 import { createHydrationCachePublication } from "./app-hydration-cache-publication.js";
-import { createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, resolveOptimisticNavigationPayload } from "./app-optimistic-routing.js";
+import { resolvePrefetchNavigationResponseUrl } from "./app-browser-prefetch-response.js";
+import { createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, matchOptimisticRouteManifestRoute, resolveOptimisticNavigationPayload } from "./app-optimistic-routing.js";
 import { removeStylesheetLinksCoveredByInlineCss } from "./app-inline-css-client.js";
 import { createElement, startTransition, use, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { flushSync } from "react-dom";
@@ -126,6 +127,7 @@ let latestClientParams = {};
 const visitedResponseCache = /* @__PURE__ */ new Map();
 let clientNavigationCacheGeneration = 0;
 let browserRouterStateHasEverCommitted = false;
+let initialPrefetchRouterState = null;
 const mpaNavigationScheduler = new AppBrowserMpaNavigationScheduler();
 const unresolvedMpaNavigation = new Promise(() => {});
 const RSC_HMR_SETTLE_DELAY_MS = 150;
@@ -193,21 +195,6 @@ 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;
 }
@@ -302,28 +289,29 @@ function createNavigationCommitEffect(options) {
 		commitClientNavigationState(navId);
 	};
 }
-async function renderNavigationPayload(payload, navigationSnapshot, targetHref, navId, historyUpdateMode, params, previousNextUrl, pendingRouterState, payloadOrigin, actionType = "navigate", operationLane = "navigation", traversalIntent = null, scrollIntent = null, restoredBfcacheIds = null, reuseCurrentBfcacheIds = true, visibleCommitMode = "transition", onCommittedState, navigationCommitKind) {
+async function renderNavigationPayload(options) {
 	syncServerActionHttpFallbackHead(null);
 	return browserNavigationController.renderNavigationPayload({
-		actionType,
+		actionType: options.actionType ?? "navigate",
 		createNavigationCommitEffect,
-		historyUpdateMode,
-		navigationSnapshot,
-		nextElements: payload,
-		operationLane,
-		payloadOrigin,
-		params,
-		pendingRouterState,
-		previousNextUrl,
-		scrollIntent,
-		restoredBfcacheIds,
-		reuseCurrentBfcacheIds,
-		targetHistoryIndex: traversalIntent === null ? void 0 : traversalIntent.targetHistoryIndex,
-		targetHref,
-		navId,
-		navigationCommitKind,
-		visibleCommitMode,
-		onCommittedState
+		historyUpdateMode: options.historyUpdateMode,
+		navigationCommitKind: options.navigationCommitKind,
+		navigationInitiationState: options.navigationInitiationState,
+		navigationSnapshot: options.navigationSnapshot,
+		navId: options.navId,
+		nextElements: options.payload,
+		onCommittedState: options.onCommittedState,
+		operationLane: options.operationLane ?? "navigation",
+		params: options.params,
+		payloadOrigin: options.payloadOrigin,
+		pendingRouterState: options.pendingRouterState,
+		previousNextUrl: options.previousNextUrl,
+		restoredBfcacheIds: options.restoredBfcacheIds ?? null,
+		reuseCurrentBfcacheIds: options.reuseCurrentBfcacheIds ?? true,
+		scrollIntent: options.scrollIntent ?? null,
+		targetHistoryIndex: options.traversalIntent?.targetHistoryIndex,
+		targetHref: options.targetHref,
+		visibleCommitMode: options.visibleCommitMode ?? "transition"
 	});
 }
 async function commitSameUrlNavigatePayload(nextElements, actionInitiation, returnValue, revalidation = "none") {
@@ -346,8 +334,8 @@ function evictVisitedResponseCacheIfNeeded() {
 }
 function readVisitedResponseCacheCandidate(rscUrl, interceptionContext, mountedSlotsHeader, navigationKind) {
 	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
-	const cached = visitedResponseCache.get(cacheKey);
-	if (!cached) return {
+	const match = findVisitedResponseCacheEntry(visitedResponseCache, rscUrl, interceptionContext);
+	if (!match) return {
 		cacheKey,
 		entry: null,
 		facts: {
@@ -356,15 +344,15 @@ function readVisitedResponseCacheCandidate(rscUrl, interceptionContext, mountedS
 		}
 	};
 	return {
-		cacheKey,
-		entry: cached,
+		cacheKey: match.cacheKey,
+		entry: match.entry,
 		facts: {
 			candidate: "present",
-			fresh: isVisitedResponseCacheEntryFresh(cached, {
+			fresh: isVisitedResponseCacheEntryFresh(match.entry, {
 				navigationKind,
 				now: Date.now()
 			}),
-			mountedSlotsMatch: cached.mountedSlotsHeader === mountedSlotsHeader,
+			mountedSlotsMatch: match.entry.elements !== void 0 || match.entry.mountedSlotsHeader === mountedSlotsHeader,
 			navigationKind
 		}
 	};
@@ -380,9 +368,9 @@ function applyVisitedResponseCacheCandidateDecision(candidate, decision) {
 	return null;
 }
 function deleteVisitedResponse(rscUrl, interceptionContext) {
-	visitedResponseCache.delete(AppElementsWire.encodeCacheKey(rscUrl, interceptionContext));
+	deleteVisitedResponseCacheEntry(visitedResponseCache, rscUrl, interceptionContext);
 }
-function storeVisitedResponseSnapshot(rscUrl, interceptionContext, snapshot, params, prefetchFallbackTtlMs = DYNAMIC_NAVIGATION_CACHE_TTL, requestMountedSlotsHeader = snapshot.mountedSlotsHeader ?? null, elements) {
+function storeVisitedResponseSnapshot(rscUrl, interceptionContext, snapshot, params, prefetchFallbackTtlMs = DYNAMIC_NAVIGATION_CACHE_TTL, requestMountedSlotsHeader = snapshot.mountedSlotsHeader ?? null, elements, seedPrefetchCache = true) {
 	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 	visitedResponseCache.delete(cacheKey);
 	evictVisitedResponseCacheIfNeeded();
@@ -395,10 +383,10 @@ function storeVisitedResponseSnapshot(rscUrl, interceptionContext, snapshot, par
 		response: snapshot
 	});
 	visitedResponseCache.set(cacheKey, entry);
-	seedPrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext, requestMountedSlotsHeader, prefetchFallbackTtlMs);
+	if (seedPrefetchCache) seedPrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext, requestMountedSlotsHeader, prefetchFallbackTtlMs);
 	return () => {
 		if (visitedResponseCache.get(cacheKey) === entry) visitedResponseCache.delete(cacheKey);
-		deletePrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext);
+		if (seedPrefetchCache) deletePrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext);
 	};
 }
 function clientNavigationSnapshotHref(snapshot) {
@@ -725,7 +713,21 @@ function registerServerActionCallback() {
 				const hashIdx = target.href.indexOf("#");
 				const actionScrollIntent = beginAppRouterScrollIntent((hashIdx !== -1 ? target.href.slice(hashIdx) : "") || null);
 				if (target.type === "push") saveScrollPosition();
-				renderNavigationPayload(Promise.resolve(elements), createClientNavigationRenderSnapshot(target.href, actionInitiation.routerState.navigationSnapshot.params), target.href, actionInitiation.navigationId, target.type === "push" ? "push" : "replace", {}, null, null, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, target.type === "push" ? "navigate" : "replace", resolveServerActionOperationLane(revalidation), null, actionScrollIntent).catch(() => {
+				renderNavigationPayload({
+					actionType: target.type === "push" ? "navigate" : "replace",
+					historyUpdateMode: target.type === "push" ? "push" : "replace",
+					navigationInitiationState: actionInitiation.routerState,
+					navigationSnapshot: createClientNavigationRenderSnapshot(target.href, actionInitiation.routerState.navigationSnapshot.params),
+					navId: actionInitiation.navigationId,
+					operationLane: resolveServerActionOperationLane(revalidation),
+					params: {},
+					payload: Promise.resolve(elements),
+					payloadOrigin: FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN,
+					pendingRouterState: null,
+					previousNextUrl: null,
+					scrollIntent: actionScrollIntent,
+					targetHref: target.href
+				}).catch(() => {
 					browserNavigationController.performHardNavigation(target.href);
 				});
 			},
@@ -763,6 +765,10 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 	Promise.all([root, initialCacheBuffer]).then(async ([elements, buffer]) => {
 		if (cacheGeneration !== clientNavigationCacheGeneration) return;
 		const metadata = AppElementsWire.readMetadata(elements);
+		initialPrefetchRouterState = {
+			pathAndSearch: initialPathAndSearch,
+			routeId: metadata.routeId
+		};
 		if (!isCompleteAppPayloadMetadata(metadata)) return;
 		const mountedSlotsHeader = getMountedSlotIdsHeader(elements);
 		const headers = createRscRequestHeaders({ mountedSlotsHeader });
@@ -781,8 +787,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 		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);
-			return storeVisitedResponseSnapshot(rscUrl, metadata.interceptionContext, snapshot, initialParams, fallbackTtlMs, mountedSlotsHeader, elements);
+			return storeVisitedResponseSnapshot(rscUrl, metadata.interceptionContext, snapshot, initialParams, fallbackTtlMs, mountedSlotsHeader, elements, false);
 		});
 	}).catch(() => {});
 	historyController.writeBootstrapHistoryMetadata();
@@ -840,6 +845,26 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 	registerNavigationRuntimeFunctions({
 		clearNavigationCaches: clearClientNavigationCaches,
 		commitHashNavigation: (href, historyUpdateMode, scroll) => historyController.commitHashOnlyNavigation(href, historyUpdateMode, scroll),
+		getPrefetchRouterState: () => {
+			if (!browserNavigationController.hasBrowserRouterState()) {
+				if (initialPrefetchRouterState) return initialPrefetchRouterState;
+				const routeManifest = getNavigationRuntime()?.bootstrap.routeManifest ?? null;
+				const match = routeManifest ? matchOptimisticRouteManifestRoute({
+					basePath: __basePath,
+					href: window.location.href,
+					routeManifest
+				}) : null;
+				return match ? {
+					pathAndSearch: createBasePathStrippedPathAndSearch(new URL(window.location.href), __basePath),
+					routeId: match.route.id
+				} : null;
+			}
+			const state = browserNavigationController.getBrowserRouterState();
+			return {
+				pathAndSearch: createSnapshotPathAndSearch(state.navigationSnapshot),
+				routeId: state.routeId
+			};
+		},
 		navigate: async function navigateRsc(href, redirectDepth = 0, navigationKind = "navigate", historyUpdateMode, previousNextUrlOverride, programmaticTransition = false, traversalIntent, scrollIntent, visibleCommitMode = "transition") {
 			abortSupersededNavigation();
 			const navigationAbortController = new AbortController();
@@ -864,12 +889,15 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 			const reuseCurrentBfcacheIds = navigationKind !== "traverse" || !historyController.isCacheInvalidationGuarded() && historyController.isCurrentBfcacheVersion(activeTraversalIntent?.historyState ?? window.history.state);
 			try {
 				const shouldUsePendingRouterState = programmaticTransition;
-				if (shouldUsePendingRouterState && hasBrowserRouterState()) pendingRouterState = beginPendingBrowserRouterState();
-				else {
+				if (hasBrowserRouterState()) {
+					if (shouldUsePendingRouterState) pendingRouterState = beginPendingBrowserRouterState();
+				} else {
 					await waitForBrowserRouterStateReady();
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
 					if (shouldUsePendingRouterState) pendingRouterState = beginPendingBrowserRouterState();
 				}
+				const navigationInitiationState = getBrowserRouterState();
+				const mountedSlotsHeader = getMountedSlotIdsHeader(navigationInitiationState.elements);
 				while (true) {
 					const url = new URL(currentHref, window.location.origin);
 					const requestState = getRequestState(navigationKind, url.pathname, currentPrevNextUrl, activeTraversalIntent?.historyState);
@@ -877,24 +905,30 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					const requestPreviousNextUrl = requestState.previousNextUrl;
 					if (navigationKind === "refresh") historyController.syncCurrentHistoryStatePreviousNextUrl(requestPreviousNextUrl, getBrowserRouterState().bfcacheIds);
 					setPendingPathname(url.pathname, navId);
-					const routerStateAtNavStart = getBrowserRouterState();
-					const elementsAtNavStart = routerStateAtNavStart.elements;
-					const mountedSlotsHeader = getMountedSlotIdsHeader(elementsAtNavStart);
 					const earlyIntentDecision = navigationKind === "navigate" ? navigationPlanner.classifyEarlyNavigationIntent({
 						basePath: __basePath,
-						currentHref: clientNavigationSnapshotHref(routerStateAtNavStart.navigationSnapshot),
+						currentHref: clientNavigationSnapshotHref(navigationInitiationState.navigationSnapshot),
 						mode: "push",
 						scroll: false,
 						targetHref: url.href
 					}) : null;
 					const shouldBypassNavigationCache = earlyIntentDecision?.kind === "flightNavigation" && earlyIntentDecision.bypassNavigationCache;
 					const requestHeaders = createRscRequestHeaders({
+						fetchPriority: "auto",
 						interceptionContext: requestInterceptionContext,
 						mountedSlotsHeader
 					});
-					const rscUrl = await createRscRequestUrl(url.pathname + url.search, requestHeaders);
 					const rewrittenNavigationHref = navigationKind === "navigate" && HAS_CLIENT_REWRITES ? resolveLoadedHybridClientRewriteHref(currentHref, __basePath) : null;
-					const additionalPrefetchRscUrls = rewrittenNavigationHref && rewrittenNavigationHref !== currentHref ? [await createRscRequestUrl(rewrittenNavigationHref, requestHeaders)] : [];
+					const targetPathAndSearch = url.pathname + url.search;
+					const additionalPrefetchPathAndSearch = rewrittenNavigationHref && rewrittenNavigationHref !== currentHref ? [rewrittenNavigationHref] : [];
+					const settledPrefetchedResponse = navigationKind === "navigate" && !shouldBypassNavigationCache ? consumePrefetchResponse(targetPathAndSearch, requestInterceptionContext, mountedSlotsHeader, { additionalRscUrls: additionalPrefetchPathAndSearch }) : null;
+					const rscUrl = settledPrefetchedResponse ? resolvePrefetchNavigationResponseUrl({
+						additionalRscUrls: additionalPrefetchPathAndSearch,
+						origin: window.location.origin,
+						responseUrl: settledPrefetchedResponse.url,
+						visibleRscUrl: targetPathAndSearch
+					}) : await createRscRequestUrl(targetPathAndSearch, requestHeaders);
+					const additionalPrefetchRscUrls = settledPrefetchedResponse ? additionalPrefetchPathAndSearch : await Promise.all(additionalPrefetchPathAndSearch.map((href) => createRscRequestUrl(href, requestHeaders)));
 					const visitedResponseCandidate = shouldBypassNavigationCache ? {
 						cacheKey: AppElementsWire.encodeCacheKey(rscUrl, requestInterceptionContext),
 						entry: null,
@@ -911,7 +945,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						visitedResponse
 					});
 					let routeManifest = navigationKind === "navigate" ? getBrowserRouteManifest() : null;
-					const hasPrefetchCandidate = prefetchProbeDecision.kind === "probe" && hasPrefetchCacheEntryForNavigation(rscUrl, requestInterceptionContext, mountedSlotsHeader, {
+					const hasPrefetchCandidate = settledPrefetchedResponse !== null || prefetchProbeDecision.kind === "probe" && hasPrefetchCacheEntryForNavigation(rscUrl, requestInterceptionContext, mountedSlotsHeader, {
 						additionalRscUrls: additionalPrefetchRscUrls,
 						notifyInvalidation: false
 					});
@@ -960,7 +994,26 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						const cachedNavigationSnapshot = createClientNavigationRenderSnapshot(currentHref, cachedParams);
 						const cachedPayload = cachedRoute.elements ? Promise.resolve(cachedRoute.elements) : decodeAppElementsPromise(createFromFetch(Promise.resolve(restoreRscResponse(cachedRoute.response))));
 						if (!browserNavigationController.isCurrentNavigation(navId)) return;
-						if (await renderNavigationPayload(cachedPayload, cachedNavigationSnapshot, currentHref, navId, currentHistoryMode, cachedParams, requestPreviousNextUrl, detachedNavigationCommits ? null : pendingRouterState, cachedRoute.elements ? COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN : VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, toActionType(navigationKind), toOperationLane(navigationKind), activeTraversalIntent, scrollIntent, restoredBfcacheIds, reuseCurrentBfcacheIds, visibleCommitMode) === "no-commit") {
+						if (await renderNavigationPayload({
+							actionType: toActionType(navigationKind),
+							historyUpdateMode: currentHistoryMode,
+							navigationCommitKind: detachedNavigationCommits ? "authoritative" : void 0,
+							navigationInitiationState,
+							navigationSnapshot: cachedNavigationSnapshot,
+							navId,
+							operationLane: toOperationLane(navigationKind),
+							params: cachedParams,
+							payload: cachedPayload,
+							payloadOrigin: cachedRoute.elements ? COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN : VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN,
+							pendingRouterState: detachedNavigationCommits ? null : pendingRouterState,
+							previousNextUrl: requestPreviousNextUrl,
+							restoredBfcacheIds,
+							reuseCurrentBfcacheIds,
+							scrollIntent,
+							targetHref: currentHref,
+							traversalIntent: activeTraversalIntent,
+							visibleCommitMode
+						}) === "no-commit") {
 							if (!browserNavigationController.isCurrentNavigation(navId)) return;
 							deleteVisitedResponse(rscUrl, requestInterceptionContext);
 							continue;
@@ -970,17 +1023,24 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					let navResponse;
 					let navResponseExpiresAt;
 					let navResponseUrl = null;
+					let prefetchedElements;
 					let fallbackReuseDecision = reuseDecision;
 					if (reuseDecision.kind === "consumePrefetch") {
-						const prefetchedResponse = await consumePrefetchResponseForNavigation(rscUrl, requestInterceptionContext, mountedSlotsHeader, {
+						const prefetchedResponse = settledPrefetchedResponse ?? await consumePrefetchResponseForNavigation(rscUrl, requestInterceptionContext, mountedSlotsHeader, {
 							additionalRscUrls: additionalPrefetchRscUrls,
 							shouldConsume: () => browserNavigationController.isCurrentNavigation(navId)
 						});
 						if (!browserNavigationController.isCurrentNavigation(navId)) return;
 						if (prefetchedResponse) {
+							prefetchedElements = prefetchedResponse.preparedElements;
 							navResponse = restoreRscResponse(prefetchedResponse, false);
 							navResponseExpiresAt = prefetchedResponse.expiresAt;
-							navResponseUrl = isAlternatePrefetchResponseUrl(prefetchedResponse.url, additionalPrefetchRscUrls) ? rscUrl : prefetchedResponse.url;
+							navResponseUrl = resolvePrefetchNavigationResponseUrl({
+								additionalRscUrls: additionalPrefetchRscUrls,
+								origin: window.location.origin,
+								responseUrl: prefetchedResponse.url,
+								visibleRscUrl: rscUrl
+							});
 						}
 						if (!navResponse) {
 							routeManifest = navigationKind === "navigate" ? getBrowserRouteManifest() : null;
@@ -1016,7 +1076,26 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 							if (optimisticPayload !== null) {
 								detachedNavigationCommits = true;
 								const optimisticNavigationSnapshot = createClientNavigationRenderSnapshot(currentHref, optimisticPayload.params);
-								renderNavigationPayload(Promise.resolve(optimisticPayload.elements), optimisticNavigationSnapshot, currentHref, navId, currentHistoryMode, optimisticPayload.params, requestPreviousNextUrl, null, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, toActionType(navigationKind), toOperationLane(navigationKind), activeTraversalIntent, scrollIntent, restoredBfcacheIds, reuseCurrentBfcacheIds, visibleCommitMode, void 0, "detached").catch((error) => {
+								renderNavigationPayload({
+									actionType: toActionType(navigationKind),
+									historyUpdateMode: currentHistoryMode,
+									navigationCommitKind: "detached",
+									navigationInitiationState,
+									navigationSnapshot: optimisticNavigationSnapshot,
+									navId,
+									operationLane: toOperationLane(navigationKind),
+									params: optimisticPayload.params,
+									payload: Promise.resolve(optimisticPayload.elements),
+									payloadOrigin: FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN,
+									pendingRouterState: null,
+									previousNextUrl: requestPreviousNextUrl,
+									restoredBfcacheIds,
+									reuseCurrentBfcacheIds,
+									scrollIntent,
+									targetHref: currentHref,
+									traversalIntent: activeTraversalIntent,
+									visibleCommitMode
+								}).catch((error) => {
 									if (browserNavigationController.isCurrentNavigation(navId)) console.error("[vinext] Optimistic RSC navigation error:", error);
 								});
 							}
@@ -1024,12 +1103,13 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					}
 					if (!navResponse) {
 						if (navigationKind === "navigate") {
-							const clientReuseManifestHeader = createClientReuseManifestHeaderFromVisibleAppState(routerStateAtNavStart);
+							const clientReuseManifestHeader = createClientReuseManifestHeaderFromVisibleAppState(navigationInitiationState);
 							if (clientReuseManifestHeader !== null) requestHeaders.set(VINEXT_CLIENT_REUSE_MANIFEST_HEADER, clientReuseManifestHeader);
 						}
 						navResponse = await fetch(rscUrl, {
 							headers: requestHeaders,
 							credentials: "include",
+							priority: "auto",
 							signal: navigationAbortController.signal
 						});
 					}
@@ -1083,13 +1163,35 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					const cacheBufferPromise = new Response(cacheBranch).arrayBuffer();
 					cacheBufferPromise.catch(() => {});
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
-					const rscPayload = decodeAppElementsPromise(createFromFetch(Promise.resolve(reactResponse)));
+					if (prefetchedElements) reactBranch.cancel().catch(() => {});
+					const rscPayload = prefetchedElements ? prefetchedElements : decodeAppElementsPromise(createFromFetch(Promise.resolve(reactResponse)));
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
 					let committedState = null;
-					if (await renderNavigationPayload(rscPayload, navigationSnapshot, currentHref, navId, currentHistoryMode, navParams, requestPreviousNextUrl, detachedNavigationCommits ? null : pendingRouterState, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, toActionType(navigationKind), toOperationLane(navigationKind), activeTraversalIntent, scrollIntent, restoredBfcacheIds, reuseCurrentBfcacheIds, visibleCommitMode, (state) => {
-						committedState = state;
-						if (activeNavigationAbortController === navigationAbortController) activeNavigationAbortController = null;
-					}, detachedNavigationCommits ? "authoritative" : void 0) !== "committed") return;
+					if (await renderNavigationPayload({
+						actionType: toActionType(navigationKind),
+						historyUpdateMode: currentHistoryMode,
+						navigationCommitKind: detachedNavigationCommits ? "authoritative" : void 0,
+						navigationInitiationState,
+						navigationSnapshot,
+						navId,
+						onCommittedState: (state) => {
+							committedState = state;
+							if (activeNavigationAbortController === navigationAbortController) activeNavigationAbortController = null;
+						},
+						operationLane: toOperationLane(navigationKind),
+						params: navParams,
+						payload: rscPayload,
+						payloadOrigin: FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN,
+						pendingRouterState: detachedNavigationCommits ? null : pendingRouterState,
+						previousNextUrl: requestPreviousNextUrl,
+						restoredBfcacheIds,
+						reuseCurrentBfcacheIds,
+						scrollIntent,
+						targetHref: currentHref,
+						traversalIntent: activeTraversalIntent,
+						visibleCommitMode: prefetchedElements ? "synchronous" : visibleCommitMode
+					}) !== "committed") return;
+					committedState ??= getBrowserRouterState();
 					try {
 						const renderedElements = await rscPayload;
 						if (navigationCacheGeneration !== clientNavigationCacheGeneration) return;
@@ -1110,7 +1212,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) {
+						} else {
 							const state = committedState;
 							const committedElements = {
 								...state.elements,
@@ -1121,9 +1223,6 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 							};
 							if (navigationCacheGeneration !== clientNavigationCacheGeneration) return;
 							storeVisitedResponseSnapshot(rscUrl, interceptionContext, snapshot, navParams, DYNAMIC_NAVIGATION_CACHE_TTL, mountedSlotsHeader, committedElements);
-						} else {
-							if (navigationCacheGeneration !== clientNavigationCacheGeneration) return;
-							seedPrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext, mountedSlotsHeader, DYNAMIC_NAVIGATION_CACHE_TTL);
 						}
 					} catch {}
 					return;
@@ -1137,7 +1236,8 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 				browserNavigationController.finalizeNavigation(navId, pendingRouterState);
 				discardedServerActionRefreshScheduler.markNavigationSettled();
 			}
-		}
+		},
+		preparePrefetchResponse: (response) => decodeAppElementsPromise(createFromFetch(Promise.resolve(response)))
 	});
 	const handlePopstate = createPopstateRestoreHandler({
 		getActiveNavigationId: browserNavigationController.getActiveNavigationId.bind(browserNavigationController),

package/dist/server/app-browser-navigation-controller.d.ts

@@ -43,6 +43,28 @@ type BrowserNavigationControllerDeps = {
   getRouteManifest?: () => RouteManifest | null;
   syncHistoryStatePreviousNextUrl?: (previousNextUrl: string | null, bfcacheIds?: Readonly<Record<string, string>> | null) => void;
 };
+type BrowserNavigationPayloadOptions = {
+  actionType: "navigate" | "replace" | "traverse";
+  createNavigationCommitEffect: BrowserNavigationCommitEffectFactory;
+  historyUpdateMode: HistoryUpdateMode | undefined;
+  navigationCommitKind?: "authoritative" | "detached";
+  navigationInitiationState: AppRouterState;
+  navigationSnapshot: ClientNavigationRenderSnapshot;
+  navId: number;
+  nextElements: Promise<AppElements> | AppElements;
+  onCommittedState?: (state: AppRouterState) => void;
+  operationLane: OperationLane;
+  params: Record<string, string | string[]>;
+  payloadOrigin: AppNavigationPayloadOrigin;
+  pendingRouterState: PendingBrowserRouterState | null;
+  previousNextUrl: string | null;
+  restoredBfcacheIds?: Readonly<Record<string, string>> | null;
+  reuseCurrentBfcacheIds?: boolean;
+  scrollIntent?: AppRouterScrollIntent | null;
+  targetHistoryIndex?: number | null;
+  targetHref: string;
+  visibleCommitMode?: NavigationRuntimeVisibleCommitMode;
+};
 type BrowserNavigationController = {
   beginNavigation(): number;
   getActiveNavigationId(): number;
@@ -60,27 +82,7 @@ type BrowserNavigationController = {
     state: AppRouterState;
     targetHref: string;
   }): boolean;
-  renderNavigationPayload(options: {
-    actionType: "navigate" | "replace" | "traverse";
-    createNavigationCommitEffect: BrowserNavigationCommitEffectFactory;
-    historyUpdateMode: HistoryUpdateMode | undefined;
-    navigationSnapshot: ClientNavigationRenderSnapshot;
-    nextElements: Promise<AppElements>;
-    operationLane: OperationLane;
-    payloadOrigin: AppNavigationPayloadOrigin;
-    params: Record<string, string | string[]>;
-    pendingRouterState: PendingBrowserRouterState | null;
-    previousNextUrl: string | null;
-    scrollIntent?: AppRouterScrollIntent | null;
-    restoredBfcacheIds?: Readonly<Record<string, string>> | null;
-    reuseCurrentBfcacheIds?: boolean;
-    targetHistoryIndex?: number | null;
-    targetHref: string;
-    navId: number;
-    navigationCommitKind?: "authoritative" | "detached";
-    visibleCommitMode?: NavigationRuntimeVisibleCommitMode;
-    onCommittedState?: (state: AppRouterState) => void;
-  }): Promise<NavigationPayloadOutcome>;
+  renderNavigationPayload(options: BrowserNavigationPayloadOptions): Promise<NavigationPayloadOutcome>;
   commitSameUrlNavigatePayload(nextElements: Promise<AppElements>, navigationSnapshot: ClientNavigationRenderSnapshot, returnValue?: {
     ok: boolean;
     data: unknown;

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

@@ -3,7 +3,7 @@ import { clearAppNavigationFailureTarget, getAppNavigationFailureTarget } from "
 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 { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, createPendingNavigationCommit } from "./app-browser-state.js";
+import { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, createPendingNavigationCommit, createPendingNavigationCommitFromElements } from "./app-browser-state.js";
 import { applyApprovedVisibleCommit, approveHmrVisibleCommit, approvePendingNavigationCommit, resolveAndClassifyNavigationCommit } from "./app-browser-visible-commit.js";
 import { startTransition, useInsertionEffect, useLayoutEffect } from "react";
 import { flushSync } from "react-dom";
@@ -255,6 +255,9 @@ function createAppBrowserNavigationController(deps = {}) {
 			pendingRouterState.settled = true;
 			pendingRouterState.resolve(committedState);
 			if (activePendingBrowserRouterState === pendingRouterState) activePendingBrowserRouterState = null;
+			if (visibleCommitMode === "synchronous") flushSync(() => {
+				setter(committedState);
+			});
 			return;
 		}
 		if (visibleCommitMode === "synchronous") {
@@ -332,6 +335,22 @@ function createAppBrowserNavigationController(deps = {}) {
 		if (!shouldScheduleRefreshForDiscardedServerAction(lifecycleOptions?.revalidation ?? "none")) return;
 		lifecycleOptions?.onDiscardedRevalidation?.();
 	}
+	function isSamePathSearchHashCommit(targetHref) {
+		if (typeof window === "undefined") return false;
+		try {
+			const currentUrl = new URL(window.location.href);
+			const targetUrl = new URL(targetHref, currentUrl.href);
+			return targetUrl.origin === currentUrl.origin && targetUrl.pathname === currentUrl.pathname && targetUrl.search !== currentUrl.search && targetUrl.hash !== "";
+		} catch {
+			return false;
+		}
+	}
+	function shouldForceSynchronousCommit(options) {
+		if (options.actionType === "traverse") return false;
+		if (options.historyUpdateMode === void 0) return false;
+		if (options.scrollIntent?.hash == null) return false;
+		return isSamePathSearchHashCommit(options.targetHref);
+	}
 	async function renderNavigationPayload(options) {
 		if (options.navId === pendingUserNavigationId) pendingUserNavigationLane = options.operationLane;
 		const renderId = allocateRenderId();
@@ -348,11 +367,10 @@ function createAppBrowserNavigationController(deps = {}) {
 		});
 		let snapshotActivated = false;
 		try {
-			const pending = await createPendingNavigationCommit({
-				currentState: getBrowserRouterState(),
+			const pendingOptions = {
+				currentState: options.navigationInitiationState,
 				navigationCommitKind: options.navigationCommitKind,
 				navigationId: options.navId,
-				nextElements: options.nextElements,
 				navigationSnapshot: options.navigationSnapshot,
 				operationLane: options.operationLane,
 				payloadOrigin: options.payloadOrigin,
@@ -361,6 +379,13 @@ function createAppBrowserNavigationController(deps = {}) {
 				restoredBfcacheIds: options.restoredBfcacheIds,
 				reuseCurrentBfcacheIds: options.reuseCurrentBfcacheIds,
 				type: options.actionType
+			};
+			const pending = options.nextElements instanceof Promise ? await createPendingNavigationCommit({
+				...pendingOptions,
+				nextElements: options.nextElements
+			}) : createPendingNavigationCommitFromElements({
+				...pendingOptions,
+				nextElements: options.nextElements
 			});
 			const approval = approvePendingNavigationCommit({
 				activeNavigationId,
@@ -402,7 +427,7 @@ function createAppBrowserNavigationController(deps = {}) {
 			claimAppRouterScrollIntentForCommit(options.scrollIntent, renderId);
 			activateNavigationSnapshot();
 			snapshotActivated = true;
-			dispatchApprovedVisibleCommit(renderId, approvedCommit, options.pendingRouterState, options.visibleCommitMode ?? "transition");
+			dispatchApprovedVisibleCommit(renderId, approvedCommit, options.pendingRouterState, shouldForceSynchronousCommit(options) ? "synchronous" : options.visibleCommitMode ?? "transition");
 		} catch (error) {
 			pendingNavigationFailureTargets.delete(renderId);
 			pendingNavigationPrePaintEffects.delete(renderId);

package/dist/server/app-browser-prefetch-response.d.ts

@@ -0,0 +1,9 @@
+//#region src/server/app-browser-prefetch-response.d.ts
+declare function resolvePrefetchNavigationResponseUrl(options: {
+  additionalRscUrls: readonly string[];
+  origin: string;
+  responseUrl: string;
+  visibleRscUrl: string;
+}): string;
+//#endregion
+export { resolvePrefetchNavigationResponseUrl };

package/dist/server/app-browser-prefetch-response.js

@@ -0,0 +1,32 @@
+import { stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
+//#region src/server/app-browser-prefetch-response.ts
+function normalizeBrowserRscUrlForReuse(url, origin) {
+	if (!url) return null;
+	try {
+		const parsed = new URL(url, origin);
+		stripRscCacheBustingSearchParam(parsed);
+		return `${parsed.pathname}${parsed.search}`;
+	} catch {
+		return null;
+	}
+}
+function isSameOriginBrowserRscUrl(url, origin) {
+	try {
+		return new URL(url, origin).origin === new URL(origin).origin;
+	} catch {
+		return false;
+	}
+}
+function canonicalizeBrowserRscResponseUrl(responseUrl, origin) {
+	try {
+		const parsed = new URL(responseUrl, origin);
+		if (parsed.origin === new URL(origin).origin) return `${parsed.pathname}${parsed.search}`;
+	} catch {}
+	return responseUrl;
+}
+function resolvePrefetchNavigationResponseUrl(options) {
+	const normalizedResponseUrl = normalizeBrowserRscUrlForReuse(options.responseUrl, options.origin);
+	return normalizedResponseUrl !== null && isSameOriginBrowserRscUrl(options.responseUrl, options.origin) && options.additionalRscUrls.some((additionalRscUrl) => normalizeBrowserRscUrlForReuse(additionalRscUrl, options.origin) === normalizedResponseUrl) ? options.visibleRscUrl : canonicalizeBrowserRscResponseUrl(options.responseUrl, options.origin);
+}
+//#endregion
+export { resolvePrefetchNavigationResponseUrl };