vinext 1.0.0-beta.3 → 1.0.0-beta.4

package/dist/server/api-handler.js

@@ -9,7 +9,7 @@ import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-medi
 import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
 import { performOnDemandRevalidate } from "./pages-revalidate.js";
 import { attachPagesPreviewApi, attachPagesRequestCookies } from "./pages-node-compat.js";
-import { isEdgeApiRuntime } from "./edge-api-runtime.js";
+import { finalizeEdgeApiResponse, isEdgeApiRuntime } from "./edge-api-runtime.js";
 import { decode } from "node:querystring";
 import { Buffer } from "node:buffer";
 //#region src/server/api-handler.ts
@@ -227,8 +227,9 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 				i18n: nextConfig.i18n ?? void 0,
 				trailingSlash: nextConfig.trailingSlash
 			} } : void 0);
-			const response = await apiModule.default(nextRequest);
-			if (!(response instanceof Response)) throw new Error("Edge API route did not return a Response");
+			const handlerResponse = await apiModule.default(nextRequest);
+			if (!(handlerResponse instanceof Response)) throw new Error("Edge API route did not return a Response");
+			const response = finalizeEdgeApiResponse(handlerResponse, "node");
 			res.statusCode = response.status;
 			res.statusMessage = response.statusText;
 			const setCookieHeaders = response.headers.getSetCookie();

package/dist/server/app-bfcache-identity.js

@@ -51,19 +51,45 @@ function createActiveSlotIdentity(id, parsed) {
 	if (interception?.slotId !== id) return null;
 	return `${id}@${interception.targetRouteId}`;
 }
+function getDirectMatchedRoutePathname(metadata) {
+	if (metadata?.metadata.interception != null || metadata?.metadata.sourcePage == null) return null;
+	const route = AppElementsWire.parseElementKey(metadata.metadata.routeId);
+	return route?.kind === "route" ? route.path : null;
+}
+function getPageMatchedUrl(parsed, metadata) {
+	const interception = metadata?.metadata.interception;
+	if (interception === null || interception === void 0) {
+		const matchedRoutePathname = getDirectMatchedRoutePathname(metadata);
+		return matchedRoutePathname === parsed.path ? matchedRoutePathname : null;
+	}
+	for (const [routeId, matchedUrl] of [[interception.sourceRouteId, interception.sourceMatchedUrl], [interception.targetRouteId, interception.targetMatchedUrl]]) {
+		const route = AppElementsWire.parseElementKey(routeId);
+		if (route?.kind === "route" && route.path === parsed.path) return matchedUrl;
+	}
+	return null;
+}
+function getTreePathname(treePath, metadata) {
+	const interception = metadata?.metadata.interception;
+	if (interception === null || interception === void 0) return getDirectMatchedRoutePathname(metadata);
+	const slot = AppElementsWire.parseElementKey(interception.slotId);
+	if (slot?.kind !== "slot") return interception.sourceMatchedUrl;
+	const treeSegments = splitPathSegments(treePath);
+	const ownerSegments = splitPathSegments(slot.treePath);
+	return treeSegments.length > ownerSegments.length && ownerSegments.every((segment, index) => treeSegments[index] === segment) && treeSegments[ownerSegments.length] === `@${slot.name}` ? interception.targetMatchedUrl : interception.sourceMatchedUrl;
+}
 /**
 * Derive BFCache identity from AppElements wire keys. Keep wire-key parsing
 * contained here until vinext has a route-manifest authority equivalent to
 * Next.js CacheNode or segment-cache state.
 */
 function createBfcacheSegmentIdentity(id, parsed, options) {
-	if (parsed.kind === "page") return `${id}@${options.pathname}`;
+	if (parsed.kind === "page") return `${id}@${getPageMatchedUrl(parsed, options.metadata) ?? options.pathname}`;
 	if (parsed.kind === "slot") {
 		const activeSlotIdentity = createActiveSlotIdentity(id, options.metadata);
 		if (activeSlotIdentity !== null) return activeSlotIdentity;
 		return `${id}@${getTreePathIdentityPrefix(options.pathname, parsed.treePath)}`;
 	}
-	if (parsed.kind === "layout" || parsed.kind === "template") return `${id}@${getTreePathIdentityPrefix(options.pathname, parsed.treePath)}`;
+	if (parsed.kind === "layout" || parsed.kind === "template") return `${id}@${getTreePathIdentityPrefix(getTreePathname(parsed.treePath, options.metadata) ?? options.pathname, parsed.treePath)}`;
 	return null;
 }
 function collectBfcacheSegmentIdCandidates(elements, metadata = readAppElementsMetadata(elements)) {

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;
 }
@@ -347,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: {
@@ -357,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
 		}
 	};
@@ -381,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();
@@ -396,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) {
@@ -778,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 });
@@ -796,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();
@@ -855,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();
@@ -879,8 +889,9 @@ 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();
@@ -903,12 +914,21 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					}) : 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,
@@ -925,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
 					});
@@ -1003,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;
@@ -1082,6 +1109,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						navResponse = await fetch(rscUrl, {
 							headers: requestHeaders,
 							credentials: "include",
+							priority: "auto",
 							signal: navigationAbortController.signal
 						});
 					}
@@ -1135,7 +1163,8 @@ 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({
@@ -1160,8 +1189,9 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						scrollIntent,
 						targetHref: currentHref,
 						traversalIntent: activeTraversalIntent,
-						visibleCommitMode
+						visibleCommitMode: prefetchedElements ? "synchronous" : visibleCommitMode
 					}) !== "committed") return;
+					committedState ??= getBrowserRouterState();
 					try {
 						const renderedElements = await rscPayload;
 						if (navigationCacheGeneration !== clientNavigationCacheGeneration) return;
@@ -1182,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,
@@ -1193,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;
@@ -1209,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

@@ -51,7 +51,7 @@ type BrowserNavigationPayloadOptions = {
   navigationInitiationState: AppRouterState;
   navigationSnapshot: ClientNavigationRenderSnapshot;
   navId: number;
-  nextElements: Promise<AppElements>;
+  nextElements: Promise<AppElements> | AppElements;
   onCommittedState?: (state: AppRouterState) => void;
   operationLane: OperationLane;
   params: Record<string, string | string[]>;

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({
+			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 };

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

@@ -133,11 +133,10 @@ declare function resolvePendingNavigationCommitDispositionDecision(options: {
   startedNavigationId: number;
   targetHref?: string;
 }): PendingNavigationCommitDispositionDecision;
-declare function createPendingNavigationCommit(options: {
+type CreatePendingNavigationCommitOptions = {
   currentState: AppRouterState;
   navigationCommitKind?: "authoritative" | "detached";
   navigationId?: number;
-  nextElements: Promise<AppElements>;
   navigationSnapshot: ClientNavigationRenderSnapshot;
   operationLane: OperationLane;
   payloadOrigin: AppNavigationPayloadOrigin;
@@ -146,6 +145,12 @@ declare function createPendingNavigationCommit(options: {
   restoredBfcacheIds?: BfcacheIdMap | null;
   reuseCurrentBfcacheIds?: boolean;
   type: "navigate" | "replace" | "traverse";
+};
+declare function createPendingNavigationCommitFromElements(options: CreatePendingNavigationCommitOptions & {
+  nextElements: AppElements;
+}): PendingNavigationCommit;
+declare function createPendingNavigationCommit(options: CreatePendingNavigationCommitOptions & {
+  nextElements: Promise<AppElements>;
 }): Promise<PendingNavigationCommit>;
 //#endregion
-export { AppNavigationPayloadOrigin, AppRouterAction, AppRouterState, type BfcacheIdMap, COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, CommittedOperationRecord, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, type HistoryTraversalIntent, type OperationLane, PendingNavigationCommit, PendingOperationRecord, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createBfcacheSegmentStateKeyMap, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createInitialBfcacheIdMap, createNextBfcacheIdMap, createPendingNavigationCommit, isCacheRestorableAppPayloadMetadata, isCompleteAppPayloadMetadata, isHistoryStateBfcacheVersionCurrent, preserveBfcacheIdsForMergedElements, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDispositionDecision, resolveServerActionRequestState };
+export { AppNavigationPayloadOrigin, AppRouterAction, AppRouterState, COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, CommittedOperationRecord, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, type HistoryTraversalIntent, type OperationLane, PendingNavigationCommit, PendingOperationRecord, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createBfcacheSegmentStateKeyMap, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createInitialBfcacheIdMap, createNextBfcacheIdMap, createPendingNavigationCommit, createPendingNavigationCommitFromElements, isCacheRestorableAppPayloadMetadata, isCompleteAppPayloadMetadata, isHistoryStateBfcacheVersionCurrent, preserveBfcacheIdsForMergedElements, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDispositionDecision, resolveServerActionRequestState };

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

@@ -279,8 +279,8 @@ function mergeSkippedLayoutSlotPreservation(options) {
 	}
 	return preservePreviousSlotIds;
 }
-async function createPendingNavigationCommit(options) {
-	const elements = await options.nextElements;
+function createPendingNavigationCommitFromElements(options) {
+	const elements = options.nextElements;
 	const metadata = AppElementsWire.readMetadata(elements);
 	const cacheEntryReuseProof = metadata.cacheEntryReuseProof ?? (requiresCacheEntryReuseProof(options.payloadOrigin) ? createCacheEntryReuseProof(null) : void 0);
 	const requestedPreviousNextUrl = options.previousNextUrl !== void 0 ? options.previousNextUrl : options.currentState.previousNextUrl;
@@ -328,5 +328,11 @@ async function createPendingNavigationCommit(options) {
 		skippedLayoutIds: metadata.skippedLayoutIds
 	};
 }
+async function createPendingNavigationCommit(options) {
+	return createPendingNavigationCommitFromElements({
+		...options,
+		nextElements: await options.nextElements
+	});
+}
 //#endregion
-export { COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createBfcacheSegmentStateKeyMap, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createInitialBfcacheIdMap, createNextBfcacheIdMap, createPendingNavigationCommit, isCacheRestorableAppPayloadMetadata, isCompleteAppPayloadMetadata, isHistoryStateBfcacheVersionCurrent, preserveBfcacheIdsForMergedElements, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDispositionDecision, resolveServerActionRequestState };
+export { COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createBfcacheSegmentStateKeyMap, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createInitialBfcacheIdMap, createNextBfcacheIdMap, createPendingNavigationCommit, createPendingNavigationCommitFromElements, isCacheRestorableAppPayloadMetadata, isCompleteAppPayloadMetadata, isHistoryStateBfcacheVersionCurrent, preserveBfcacheIdsForMergedElements, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDispositionDecision, resolveServerActionRequestState };

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

@@ -1,11 +1,11 @@
 import { ClassificationReason } from "../build/layout-classification-types.js";
 import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { AppOutgoingElements } from "./app-elements-wire.js";
+import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageFontPreload, LayoutClassificationOptions } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
 import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
-import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
 import { CachedAppPageValue } from "../shims/cache-handler.js";

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

@@ -348,13 +348,17 @@ async function dispatchAppPageInner(options) {
 	}
 	if (options.skipStaticParamsValidation !== true && !(options.isProduction && isForceDynamic)) {
 		const dynamicParamsResponse = await validateAppPageDynamicParams({
-			clearRequestContext: options.clearRequestContext,
 			enforceStaticParamsOnly: options.dynamicParamsConfig === false,
 			generateStaticParams: options.generateStaticParams,
 			isDynamicRoute: route.isDynamic,
 			params: options.staticParamsValidationParams ?? options.params
 		});
-		if (dynamicParamsResponse) return dynamicParamsResponse;
+		if (dynamicParamsResponse) {
+			const renderedNotFound = await options.renderHttpAccessFallbackPage(404, { matchedParams: options.params }, options.middlewareContext);
+			if (renderedNotFound) return renderedNotFound;
+			options.clearRequestContext();
+			return dynamicParamsResponse;
+		}
 	}
 	const fallbackShellResponse = options.pprRuntime ? await options.pprRuntime.tryServe(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic) : null;
 	if (fallbackShellResponse) return fallbackShellResponse;

package/dist/server/app-page-element-builder.d.ts

@@ -1,9 +1,9 @@
 import { MetadataFileRoute } from "./metadata-routes.js";
 import { AppElements } from "./app-elements-wire.js";
+import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { ApplyAppPageFileBasedMetadata } from "./app-page-head.js";
 import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
-import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPageErrorModule, AppPageModule, AppPageRouteWiringRoute } from "./app-page-route-wiring.js";
 
 //#region src/server/app-page-element-builder.d.ts
@@ -66,6 +66,7 @@ type BuildPageElementsOptions<TModule extends AppPageModule = AppPageModule, TEr
   basePath?: string; /** Configured next.config `trailingSlash`, threaded into canonical URL rendering. */
   trailingSlash?: boolean; /** Serialized next.config `htmlLimitedBots` regexp source. */
   htmlLimitedBots?: string;
+  scriptNonce?: string;
 };
 type AppPageNavigationParamModule = {
   default?: unknown;

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

@@ -254,6 +254,7 @@ async function buildPageElements(options) {
 		resolvedMetadata,
 		resolvedMetadataPathname: routePath,
 		resolvedViewport,
+		scriptNonce: options.scriptNonce,
 		streamingMetadata,
 		streamingMetadataOutlet,
 		streamingMetadataOutletSuspended: streamGeneratedHead,

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

@@ -1,10 +1,10 @@
 import { ClientReuseManifestParseResult, ClientReuseManifestSkipDisposition } from "./client-reuse-manifest.js";
 import { AppOutgoingElements } from "./app-elements-wire.js";
+import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageFontPreload, AppPageSpecialError, LayoutClassificationOptions } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
 import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
-import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
 import { CachedAppPageValue } from "../shims/cache-handler.js";