vinext 0.0.51 → 0.0.53

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

@@ -1,22 +1,24 @@
 import { stripBasePath } from "../utils/base-path.js";
-import { ACTION_REDIRECT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER } from "./headers.js";
+import { ACTION_REDIRECT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RSC_REDIRECT_HEADER } from "./headers.js";
 import { DANGEROUS_URL_BLOCK_MESSAGE, isDangerousScheme } from "../shims/url-safety.js";
+import { AppElementsWire } from "./app-elements-wire.js";
 import { APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI } from "./app-rsc-render-mode.js";
 import { installWindowNext } from "../client/window-next.js";
 import { scrollToHashTargetOnNextFrame } from "../shims/hash-scroll.js";
+import { getNavigationRuntime, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
-import { AppElementsWire } from "./app-elements-wire.js";
 import { getMountedSlotIdsHeader, resolveVisitedResponseInterceptionContext } from "./app-elements.js";
+import { resolveManifestNavigationInterceptionContext } from "./app-browser-interception-context.js";
 import { createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
 import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createRscRequestHeaders, createRscRequestUrl, getVinextRscCompatibilityId, resolveHardNavigationTargetFromRscResponse, resolveRscCompatibilityNavigationDecision } from "./app-rsc-cache-busting.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
-import { __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponse, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, getClientNavigationRenderContext, getCurrentInterceptionContext, getCurrentNextUrl, invalidatePrefetchCache, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, restoreRscResponse, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname } from "../shims/navigation.js";
+import { __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponse, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, getClientNavigationRenderContext, getPrefetchCache, invalidatePrefetchCache, navigateClientSide, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, restoreRscResponse, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname } from "../shims/navigation.js";
 import { DevRecoveryBoundary, RedirectBoundary } from "../shims/error-boundary.js";
 import { ElementsContext, Slot } from "../shims/slot.js";
 import "../client/instrumentation-client.js";
-import { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, isServerActionResult, parseServerActionRevalidationHeader, shouldClearClientNavigationCachesForServerActionResult } from "./app-browser-action-result.js";
+import { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, isServerActionResult, parseServerActionRevalidationHeader, resolveServerActionRedirectLocation, shouldClearClientNavigationCachesForServerActionResult } from "./app-browser-action-result.js";
 import { chunksToReadableStream, createProgressiveRscStream, getVinextBrowserGlobal } from "./app-browser-stream.js";
-import { resolveInterceptionContextFromPreviousNextUrl, resolveServerActionRequestState } from "./app-browser-state.js";
+import { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, isCacheRestorableAppPayloadMetadata, resolveInterceptionContextFromPreviousNextUrl, resolveServerActionRequestState } from "./app-browser-state.js";
 import { clearHardNavigationLoopGuard, createAppBrowserNavigationController } from "./app-browser-navigation-controller.js";
 import { consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition } from "./app-browser-hydration.js";
 import { createPopstateRestoreHandler } from "./app-browser-popstate.js";
@@ -25,6 +27,7 @@ import { dismissOverlay } from "./dev-error-overlay-store.js";
 import { devOnCaughtError, devOnUncaughtError, installDevErrorOverlay } from "./dev-error-overlay.js";
 import { throwOnServerActionNotFound } from "./server-action-not-found.js";
 import { resolveRscRedirectLifecycleHop } from "./app-browser-rsc-redirect.js";
+import { createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, resolveOptimisticNavigationPayload } from "./app-optimistic-routing.js";
 import { createElement, startTransition, use, useLayoutEffect, useRef, useState } from "react";
 import { createFromFetch, createFromReadableStream, createTemporaryReferenceSet, encodeReply, setServerCallback } from "@vitejs/plugin-rsc/browser";
 import { hydrateRoot } from "react-dom/client";
@@ -44,8 +47,11 @@ const MAX_VISITED_RESPONSE_CACHE_SIZE = 50;
 const VISITED_RESPONSE_CACHE_TTL = 5 * 6e4;
 const MAX_TRAVERSAL_CACHE_TTL = 30 * 6e4;
 const CLIENT_RSC_COMPATIBILITY_ID = getVinextRscCompatibilityId();
+const optimisticRouteTemplates = /* @__PURE__ */ new Map();
+const optimisticRouteTemplateSources = /* @__PURE__ */ new Set();
+const optimisticRouteTemplateLearning = /* @__PURE__ */ new Map();
 function getBrowserRouteManifest() {
-	return window.__VINEXT_ROUTE_MANIFEST__ ?? null;
+	return getNavigationRuntime()?.bootstrap.routeManifest ?? null;
 }
 const browserNavigationController = createAppBrowserNavigationController({
 	getRouteManifest: getBrowserRouteManifest,
@@ -53,9 +59,7 @@ const browserNavigationController = createAppBrowserNavigationController({
 });
 const discardedServerActionRefreshScheduler = createDiscardedServerActionRefreshScheduler({ runRefresh() {
 	clearClientNavigationCaches();
-	const rscNavigate = window.__VINEXT_RSC_NAVIGATE__;
-	if (typeof rscNavigate !== "function") return;
-	rscNavigate(window.location.href, 0, "refresh", void 0, void 0, true);
+	getNavigationRuntime()?.functions.navigate?.(window.location.href, 0, "refresh", void 0, void 0, true);
 } });
 const NavigationCommitSignal = browserNavigationController.NavigationCommitSignal;
 function parseEncodedJsonHeader(value) {
@@ -139,11 +143,80 @@ function clearVisitedResponseCache() {
 }
 function clearPrefetchState() {
 	invalidatePrefetchCache();
+	optimisticRouteTemplates.clear();
+	optimisticRouteTemplateSources.clear();
+	optimisticRouteTemplateLearning.clear();
 }
 function clearClientNavigationCaches() {
 	clearVisitedResponseCache();
 	clearPrefetchState();
 }
+function isSettledPrefetchCacheEntry(entry) {
+	return entry.outcome === "cache-seeded" && entry.pending === void 0 && entry.snapshot !== void 0;
+}
+function parsePrefetchCacheKey(cacheKey) {
+	const separatorIndex = cacheKey.indexOf("\0");
+	if (separatorIndex === -1) return {
+		interceptionContext: null,
+		rscUrl: cacheKey
+	};
+	return {
+		interceptionContext: cacheKey.slice(separatorIndex + 1),
+		rscUrl: cacheKey.slice(0, separatorIndex)
+	};
+}
+async function learnOptimisticRouteTemplateFromPrefetch(options) {
+	const source = parsePrefetchCacheKey(options.cacheKey);
+	if (source.interceptionContext !== options.interceptionContext) return false;
+	if ((options.entry.snapshot.mountedSlotsHeader ?? null) !== options.mountedSlotsHeader) return false;
+	if (options.interceptionContext !== null) return false;
+	const elements = await decodeAppElementsPromise(createFromFetch(Promise.resolve(restoreRscResponse(options.entry.snapshot))));
+	const template = createOptimisticRouteTemplate({
+		allowLoadingShell: options.entry.optimisticRouteShell === true,
+		basePath: __basePath,
+		elements,
+		href: options.entry.snapshot.url || source.rscUrl,
+		interceptionContext: options.interceptionContext,
+		mountedSlotsHeader: options.mountedSlotsHeader,
+		routeManifest: options.routeManifest
+	});
+	if (template === null) return false;
+	optimisticRouteTemplates.set(getOptimisticRouteTemplateKey({
+		interceptionContext: options.interceptionContext,
+		mountedSlotsHeader: options.mountedSlotsHeader,
+		routeId: template.routeId
+	}), template);
+	return true;
+}
+async function learnOptimisticRouteTemplatesFromPrefetchCache(options) {
+	if (options.routeManifest === null) return;
+	const learning = [...optimisticRouteTemplateLearning.values()];
+	for (const [cacheKey, entry] of getPrefetchCache()) {
+		const sourceKey = getOptimisticPrefetchSourceKey({
+			cacheKey,
+			interceptionContext: options.interceptionContext,
+			mountedSlotsHeader: options.mountedSlotsHeader
+		});
+		if (optimisticRouteTemplateSources.has(sourceKey)) continue;
+		if (optimisticRouteTemplateLearning.has(sourceKey)) continue;
+		if (!isSettledPrefetchCacheEntry(entry)) continue;
+		const promise = learnOptimisticRouteTemplateFromPrefetch({
+			cacheKey,
+			entry,
+			interceptionContext: options.interceptionContext,
+			mountedSlotsHeader: options.mountedSlotsHeader,
+			routeManifest: options.routeManifest
+		}).then((learned) => {
+			if (learned) optimisticRouteTemplateSources.add(sourceKey);
+		}).finally(() => {
+			optimisticRouteTemplateLearning.delete(sourceKey);
+		});
+		optimisticRouteTemplateLearning.set(sourceKey, promise);
+		learning.push(promise);
+	}
+	if (learning.length === 0) return;
+	await Promise.allSettled(learning);
+}
 function syncCurrentHistoryStatePreviousNextUrl(previousNextUrl) {
 	if (readHistoryStatePreviousNextUrl(window.history.state) === previousNextUrl) return;
 	const nextHistoryState = createHistoryStateWithPreviousNextUrl(window.history.state, previousNextUrl);
@@ -194,7 +267,7 @@ function createNavigationCommitEffect(options) {
 		commitClientNavigationState(navId);
 	};
 }
-async function renderNavigationPayload(payload, navigationSnapshot, targetHref, navId, historyUpdateMode, params, previousNextUrl, pendingRouterState, actionType = "navigate", operationLane = "navigation", traversalIntent = null) {
+async function renderNavigationPayload(payload, navigationSnapshot, targetHref, navId, historyUpdateMode, params, previousNextUrl, pendingRouterState, payloadOrigin, actionType = "navigate", operationLane = "navigation", traversalIntent = null) {
 	try {
 		return await browserNavigationController.renderNavigationPayload({
 			actionType,
@@ -206,6 +279,7 @@ async function renderNavigationPayload(payload, navigationSnapshot, targetHref,
 			navigationSnapshot,
 			nextElements: payload,
 			operationLane,
+			payloadOrigin,
 			params,
 			pendingRouterState,
 			previousNextUrl,
@@ -274,7 +348,7 @@ function storeVisitedResponseSnapshot(rscUrl, interceptionContext, snapshot, par
 		response: snapshot
 	});
 }
-function getRequestState(navigationKind, previousNextUrlOverride, traverseHistoryState) {
+function getRequestState(navigationKind, targetPathname, previousNextUrlOverride, traverseHistoryState) {
 	if (previousNextUrlOverride !== void 0) return {
 		interceptionContext: resolveInterceptionContextFromPreviousNextUrl(previousNextUrlOverride, __basePath),
 		previousNextUrl: previousNextUrlOverride
@@ -286,9 +360,19 @@ function getRequestState(navigationKind, previousNextUrlOverride, traverseHistor
 				interceptionContext: resolveInterceptionContextFromPreviousNextUrl(currentPreviousNextUrl, __basePath),
 				previousNextUrl: currentPreviousNextUrl
 			};
+			const manifestInterceptionContext = resolveManifestNavigationInterceptionContext({
+				basePath: __basePath,
+				currentPathname: window.location.pathname,
+				routeManifest: getBrowserRouteManifest(),
+				targetPathname
+			});
+			if (manifestInterceptionContext !== null) return {
+				interceptionContext: manifestInterceptionContext,
+				previousNextUrl: window.location.pathname + window.location.search
+			};
 			return {
-				interceptionContext: getCurrentInterceptionContext(),
-				previousNextUrl: getCurrentNextUrl()
+				interceptionContext: null,
+				previousNextUrl: null
 			};
 		}
 		case "traverse": {
@@ -338,7 +422,11 @@ function BrowserRoot({ initialElements, initialNavigationSnapshot }) {
 	useLayoutEffect(() => {
 		const detach = browserNavigationController.attachBrowserRouterState(setTreeStateValue, stateRef);
 		browserRouterStateHasEverCommitted = true;
-		window.__VINEXT_HYDRATED_AT = performance.now();
+		const hydratedAt = performance.now();
+		window.__VINEXT_HYDRATED_AT = hydratedAt;
+		window.__NEXT_HYDRATED = true;
+		window.__NEXT_HYDRATED_AT = hydratedAt;
+		window.__NEXT_HYDRATED_CB?.();
 		return () => {
 			detach();
 			setMountedSlotsHeader(null);
@@ -346,7 +434,7 @@ function BrowserRoot({ initialElements, initialNavigationSnapshot }) {
 	}, [setTreeStateValue]);
 	useLayoutEffect(() => {
 		setMountedSlotsHeader(getMountedSlotIdsHeader(stateRef.current.elements));
-		window.__VINEXT_PING_VISIBLE_LINKS__?.();
+		getNavigationRuntime()?.functions.pingVisibleLinks?.();
 	}, [treeState.elements]);
 	useLayoutEffect(() => {
 		if (treeState.renderId !== 0) return;
@@ -429,16 +517,17 @@ function recoverFromBadInitialRscResponse(reason) {
 }
 async function readInitialRscStream() {
 	const vinext = getVinextBrowserGlobal();
-	if (vinext.__VINEXT_RSC__ || vinext.__VINEXT_RSC_CHUNKS__ || vinext.__VINEXT_RSC_DONE__) {
+	const runtimeRsc = getNavigationRuntime()?.bootstrap.rsc;
+	if (runtimeRsc || vinext.__VINEXT_RSC_CHUNKS__ || vinext.__VINEXT_RSC_DONE__) {
 		clearReloadFlag();
 		clearHardNavigationLoopGuard();
-		if (vinext.__VINEXT_RSC__) {
-			const embedData = vinext.__VINEXT_RSC__;
-			delete vinext.__VINEXT_RSC__;
-			const params = embedData.params ?? {};
-			if (embedData.params) applyClientParams(embedData.params);
-			if (embedData.nav) restoreHydrationNavigationContext(embedData.nav.pathname, embedData.nav.searchParams, params);
-			return chunksToReadableStream(embedData.rsc);
+		if (runtimeRsc) {
+			applyRuntimeRscBootstrap(runtimeRsc);
+			if (runtimeRsc.done) {
+				registerNavigationRuntimeBootstrap({ rsc: void 0 });
+				return chunksToReadableStream(runtimeRsc.rsc);
+			}
+			return createProgressiveRscStream();
 		}
 		const params = vinext.__VINEXT_RSC_PARAMS__ ?? {};
 		if (vinext.__VINEXT_RSC_PARAMS__) applyClientParams(vinext.__VINEXT_RSC_PARAMS__);
@@ -464,6 +553,11 @@ async function readInitialRscStream() {
 	restoreHydrationNavigationContext(window.location.pathname, window.location.search, params);
 	return rscResponse.body;
 }
+function applyRuntimeRscBootstrap(rsc) {
+	const params = rsc.params ?? {};
+	if (rsc.params) applyClientParams(rsc.params);
+	if (rsc.nav) restoreHydrationNavigationContext(rsc.nav.pathname, rsc.nav.searchParams, params);
+}
 function registerServerActionCallback() {
 	setServerCallback(async (id, args) => {
 		const temporaryReferences = createTemporaryReferenceSet();
@@ -488,15 +582,24 @@ function registerServerActionCallback() {
 				console.error(DANGEROUS_URL_BLOCK_MESSAGE);
 				return;
 			}
+			const historyUpdateMode = (fetchResponse.headers.get("x-action-redirect-type") ?? "push") === "push" ? "push" : "replace";
+			const hardNavigationMode = historyUpdateMode === "push" ? "assign" : "replace";
+			let redirectLocation;
 			try {
-				if (new URL(actionRedirect, window.location.origin).origin !== window.location.origin) {
-					window.location.href = actionRedirect;
-					return;
-				}
-			} catch {}
+				redirectLocation = resolveServerActionRedirectLocation({
+					currentHref: actionInitiation.href,
+					location: actionRedirect,
+					origin: window.location.origin
+				});
+			} catch {
+				clearClientNavigationCaches();
+				browserNavigationController.performHardNavigation(actionRedirect, hardNavigationMode);
+				return;
+			}
 			clearClientNavigationCaches();
-			if ((fetchResponse.headers.get("x-action-redirect-type") ?? "replace") === "push") window.location.assign(actionRedirect);
-			else window.location.replace(actionRedirect);
+			startTransition(() => {
+				navigateClientSide(redirectLocation.href, historyUpdateMode, true, true);
+			});
 			return;
 		}
 		if (resolveRscCompatibilityNavigationDecision({
@@ -506,7 +609,7 @@ function registerServerActionCallback() {
 			responseCompatibilityId: fetchResponse.headers.get("X-Vinext-RSC-Compatibility-Id"),
 			responseUrl: fetchResponse.url
 		}).kind === "hard-navigate") {
-			window.location.reload();
+			browserNavigationController.performHardNavigation(actionInitiation.href);
 			return;
 		}
 		const revalidation = parseServerActionRevalidationHeader(fetchResponse.headers);
@@ -557,150 +660,201 @@ function bootstrapHydration(rscStream) {
 		options: hydrateRootOptions,
 		startTransition
 	});
-	window.__VINEXT_CLEAR_NAV_CACHES__ = clearClientNavigationCaches;
-	window.__VINEXT_RSC_COMMIT_HASH_NAVIGATION__ = commitHashOnlyNavigation;
-	window.__VINEXT_RSC_NAVIGATE__ = async function navigateRsc(href, redirectDepth = 0, navigationKind = "navigate", historyUpdateMode, previousNextUrlOverride, programmaticTransition = false, traversalIntent) {
-		let pendingRouterState = null;
-		const navId = browserNavigationController.beginNavigation();
-		discardedServerActionRefreshScheduler.markNavigationStart();
-		let currentHref = href;
-		let currentHistoryMode = historyUpdateMode;
-		let currentPrevNextUrl = previousNextUrlOverride;
-		let redirectCount = redirectDepth;
-		const activeTraversalIntent = navigationKind === "traverse" ? traversalIntent ?? resolveHistoryTraversalIntent({
-			currentHistoryIndex: currentHistoryTraversalIndex,
-			historyState: window.history.state
-		}) : null;
-		try {
-			const shouldUsePendingRouterState = programmaticTransition;
-			if (shouldUsePendingRouterState && hasBrowserRouterState()) pendingRouterState = beginPendingBrowserRouterState();
-			else {
-				await waitForBrowserRouterStateReady();
-				if (!browserNavigationController.isCurrentNavigation(navId)) return;
-				if (shouldUsePendingRouterState) pendingRouterState = beginPendingBrowserRouterState();
-			}
-			while (true) {
-				const url = new URL(currentHref, window.location.origin);
-				const requestState = getRequestState(navigationKind, currentPrevNextUrl, activeTraversalIntent?.historyState);
-				const requestInterceptionContext = requestState.interceptionContext;
-				const requestPreviousNextUrl = requestState.previousNextUrl;
-				if (navigationKind === "refresh") syncCurrentHistoryStatePreviousNextUrl(requestPreviousNextUrl);
-				setPendingPathname(url.pathname, navId);
-				const elementsAtNavStart = getBrowserRouterState().elements;
-				const mountedSlotsHeader = getMountedSlotIdsHeader(elementsAtNavStart);
-				const requestHeaders = createRscRequestHeaders({
-					interceptionContext: requestInterceptionContext,
-					renderMode: navigationKind === "refresh" ? APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI : void 0
-				});
-				if (mountedSlotsHeader) requestHeaders.set(VINEXT_MOUNTED_SLOTS_HEADER, mountedSlotsHeader);
-				const rscUrl = await createRscRequestUrl(url.pathname + url.search, requestHeaders);
-				const cachedRoute = getVisitedResponse(rscUrl, requestInterceptionContext, mountedSlotsHeader, navigationKind);
-				if (cachedRoute) {
+	registerNavigationRuntimeFunctions({
+		clearNavigationCaches: clearClientNavigationCaches,
+		commitHashNavigation: commitHashOnlyNavigation,
+		navigate: async function navigateRsc(href, redirectDepth = 0, navigationKind = "navigate", historyUpdateMode, previousNextUrlOverride, programmaticTransition = false, traversalIntent) {
+			let pendingRouterState = null;
+			const navId = browserNavigationController.beginNavigation();
+			discardedServerActionRefreshScheduler.markNavigationStart();
+			let currentHref = href;
+			let currentHistoryMode = historyUpdateMode;
+			let currentPrevNextUrl = previousNextUrlOverride;
+			let redirectCount = redirectDepth;
+			let detachedNavigationCommits = false;
+			const activeTraversalIntent = navigationKind === "traverse" ? traversalIntent ?? resolveHistoryTraversalIntent({
+				currentHistoryIndex: currentHistoryTraversalIndex,
+				historyState: window.history.state
+			}) : null;
+			try {
+				const shouldUsePendingRouterState = programmaticTransition;
+				if (shouldUsePendingRouterState && hasBrowserRouterState()) pendingRouterState = beginPendingBrowserRouterState();
+				else {
+					await waitForBrowserRouterStateReady();
+					if (!browserNavigationController.isCurrentNavigation(navId)) return;
+					if (shouldUsePendingRouterState) pendingRouterState = beginPendingBrowserRouterState();
+				}
+				while (true) {
+					const url = new URL(currentHref, window.location.origin);
+					const requestState = getRequestState(navigationKind, url.pathname, currentPrevNextUrl, activeTraversalIntent?.historyState);
+					const requestInterceptionContext = requestState.interceptionContext;
+					const requestPreviousNextUrl = requestState.previousNextUrl;
+					if (navigationKind === "refresh") syncCurrentHistoryStatePreviousNextUrl(requestPreviousNextUrl);
+					setPendingPathname(url.pathname, navId);
+					const elementsAtNavStart = getBrowserRouterState().elements;
+					const mountedSlotsHeader = getMountedSlotIdsHeader(elementsAtNavStart);
+					const requestHeaders = createRscRequestHeaders({
+						interceptionContext: requestInterceptionContext,
+						renderMode: navigationKind === "refresh" ? APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI : void 0
+					});
+					if (mountedSlotsHeader) requestHeaders.set(VINEXT_MOUNTED_SLOTS_HEADER, mountedSlotsHeader);
+					const rscUrl = await createRscRequestUrl(url.pathname + url.search, requestHeaders);
+					const cachedRoute = getVisitedResponse(rscUrl, requestInterceptionContext, mountedSlotsHeader, navigationKind);
+					if (cachedRoute) {
+						const compatibilityDecision = resolveRscCompatibilityNavigationDecision({
+							clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
+							currentHref,
+							origin: window.location.origin,
+							responseCompatibilityId: cachedRoute.response.compatibilityIdHeader,
+							responseUrl: cachedRoute.response.url
+						});
+						if (compatibilityDecision.kind === "hard-navigate") {
+							browserNavigationController.performHardNavigation(compatibilityDecision.hardNavigationTarget);
+							return;
+						}
+						if (!browserNavigationController.isCurrentNavigation(navId)) return;
+						const cachedParams = cachedRoute.params;
+						const cachedNavigationSnapshot = createClientNavigationRenderSnapshot(currentHref, cachedParams);
+						const cachedPayload = decodeAppElementsPromise(createFromFetch(Promise.resolve(restoreRscResponse(cachedRoute.response))));
+						if (!browserNavigationController.isCurrentNavigation(navId)) return;
+						await renderNavigationPayload(cachedPayload, cachedNavigationSnapshot, currentHref, navId, currentHistoryMode, cachedParams, requestPreviousNextUrl, detachedNavigationCommits ? null : pendingRouterState, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, toActionType(navigationKind), toOperationLane(navigationKind), activeTraversalIntent);
+						return;
+					}
+					let navResponse;
+					let navResponseUrl = null;
+					if (navigationKind !== "refresh") {
+						const prefetchedResponse = consumePrefetchResponse(rscUrl, requestInterceptionContext, mountedSlotsHeader);
+						if (prefetchedResponse) {
+							navResponse = restoreRscResponse(prefetchedResponse, false);
+							navResponseUrl = prefetchedResponse.url;
+						}
+					}
+					if (!navResponse && navigationKind === "navigate") {
+						const routeManifest = getBrowserRouteManifest();
+						await learnOptimisticRouteTemplatesFromPrefetchCache({
+							interceptionContext: requestInterceptionContext,
+							mountedSlotsHeader,
+							routeManifest
+						});
+						if (!browserNavigationController.isCurrentNavigation(navId)) return;
+						if (routeManifest !== null) {
+							const optimisticPayload = resolveOptimisticNavigationPayload({
+								basePath: __basePath,
+								href: currentHref,
+								interceptionContext: requestInterceptionContext,
+								mountedSlotsHeader,
+								routeManifest,
+								templates: optimisticRouteTemplates
+							});
+							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).catch((error) => {
+									if (browserNavigationController.isCurrentNavigation(navId)) console.error("[vinext] Optimistic RSC navigation error:", error);
+								});
+							}
+						}
+					}
+					if (!navResponse) navResponse = await fetch(rscUrl, {
+						headers: requestHeaders,
+						credentials: "include"
+					});
+					if (!browserNavigationController.isCurrentNavigation(navId)) return;
+					const isRscResponse = (navResponse.headers.get("content-type") ?? "").startsWith("text/x-component");
+					if (!navResponse.ok || !isRscResponse || !navResponse.body) {
+						const responseUrl = navResponseUrl ?? navResponse.url;
+						browserNavigationController.performHardNavigation(resolveHardNavigationTargetFromRscResponse(responseUrl, currentHref, window.location.origin));
+						return;
+					}
 					const compatibilityDecision = resolveRscCompatibilityNavigationDecision({
 						clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
 						currentHref,
 						origin: window.location.origin,
-						responseCompatibilityId: cachedRoute.response.compatibilityIdHeader,
-						responseUrl: cachedRoute.response.url
+						responseCompatibilityId: navResponse.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER),
+						responseUrl: navResponseUrl ?? navResponse.url
 					});
 					if (compatibilityDecision.kind === "hard-navigate") {
-						window.location.href = compatibilityDecision.hardNavigationTarget;
+						browserNavigationController.performHardNavigation(compatibilityDecision.hardNavigationTarget);
+						return;
+					}
+					const redirectDecision = resolveRscRedirectLifecycleHop({
+						currentHref,
+						historyUpdateMode: currentHistoryMode ?? "replace",
+						origin: window.location.origin,
+						redirectDepth: redirectCount,
+						requestPreviousNextUrl,
+						responseUrl: navResponseUrl ?? navResponse.url
+					});
+					if (redirectDecision.kind === "terminal-hard-navigation") {
+						if (redirectDecision.reason === "maxRedirectsExceeded") console.error("[vinext] Too many RSC redirects — aborting navigation to prevent infinite loop.");
+						browserNavigationController.performHardNavigation(redirectDecision.href);
 						return;
 					}
+					if (redirectDecision.kind === "follow") {
+						currentHref = redirectDecision.href;
+						currentHistoryMode = redirectDecision.historyUpdateMode;
+						currentPrevNextUrl = redirectDecision.previousNextUrl;
+						redirectCount = redirectDecision.redirectDepth;
+						continue;
+					}
+					const flightRedirectTarget = navResponse.headers.get(VINEXT_RSC_REDIRECT_HEADER);
+					if (flightRedirectTarget) {
+						navResponse.body?.cancel().catch(() => {});
+						const resolvedTarget = new URL(flightRedirectTarget, window.location.origin);
+						if (resolvedTarget.origin !== window.location.origin) {
+							browserNavigationController.performHardNavigation(resolvedTarget.href);
+							return;
+						}
+						if (redirectCount >= 10) {
+							console.error("[vinext] Too many RSC redirects — aborting navigation to prevent infinite loop.");
+							browserNavigationController.performHardNavigation(resolvedTarget.href);
+							return;
+						}
+						currentHref = `${resolvedTarget.pathname}${resolvedTarget.search}${resolvedTarget.hash}`;
+						redirectCount += 1;
+						continue;
+					}
+					const navParams = parseEncodedJsonHeader(navResponse.headers.get("X-Vinext-Params")) ?? {};
+					const navigationSnapshot = createClientNavigationRenderSnapshot(currentHref, navParams);
+					const navBody = navResponse.body;
+					if (!navBody) return;
+					const [reactBranch, cacheBranch] = navBody.tee();
+					const reactResponse = new Response(reactBranch, {
+						status: navResponse.status,
+						headers: navResponse.headers
+					});
+					const cacheBufferPromise = new Response(cacheBranch).arrayBuffer();
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
-					const cachedParams = cachedRoute.params;
-					const cachedNavigationSnapshot = createClientNavigationRenderSnapshot(currentHref, cachedParams);
-					const cachedPayload = decodeAppElementsPromise(createFromFetch(Promise.resolve(restoreRscResponse(cachedRoute.response))));
+					const rscPayload = decodeAppElementsPromise(createFromFetch(Promise.resolve(reactResponse)));
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
-					await renderNavigationPayload(cachedPayload, cachedNavigationSnapshot, currentHref, navId, currentHistoryMode, cachedParams, requestPreviousNextUrl, pendingRouterState, toActionType(navigationKind), toOperationLane(navigationKind), activeTraversalIntent);
-					return;
-				}
-				let navResponse;
-				let navResponseUrl = null;
-				if (navigationKind !== "refresh") {
-					const prefetchedResponse = consumePrefetchResponse(rscUrl, requestInterceptionContext, mountedSlotsHeader);
-					if (prefetchedResponse) {
-						navResponse = restoreRscResponse(prefetchedResponse, false);
-						navResponseUrl = prefetchedResponse.url;
+					if (await renderNavigationPayload(rscPayload, navigationSnapshot, currentHref, navId, currentHistoryMode, navParams, requestPreviousNextUrl, detachedNavigationCommits ? null : pendingRouterState, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, toActionType(navigationKind), toOperationLane(navigationKind), activeTraversalIntent) !== "committed") return;
+					if (!browserNavigationController.isCurrentNavigation(navId)) return;
+					const resolvedElements = await rscPayload;
+					const metadata = AppElementsWire.readMetadata(resolvedElements);
+					if (!isCacheRestorableAppPayloadMetadata(metadata)) {
+						cacheBufferPromise.catch(() => {});
+						return;
 					}
-				}
-				if (!navResponse) navResponse = await fetch(rscUrl, {
-					headers: requestHeaders,
-					credentials: "include"
-				});
-				if (!browserNavigationController.isCurrentNavigation(navId)) return;
-				const isRscResponse = (navResponse.headers.get("content-type") ?? "").startsWith("text/x-component");
-				if (!navResponse.ok || !isRscResponse || !navResponse.body) {
-					const responseUrl = navResponseUrl ?? navResponse.url;
-					window.location.href = resolveHardNavigationTargetFromRscResponse(responseUrl, currentHref, window.location.origin);
-					return;
-				}
-				const compatibilityDecision = resolveRscCompatibilityNavigationDecision({
-					clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
-					currentHref,
-					origin: window.location.origin,
-					responseCompatibilityId: navResponse.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER),
-					responseUrl: navResponseUrl ?? navResponse.url
-				});
-				if (compatibilityDecision.kind === "hard-navigate") {
-					window.location.href = compatibilityDecision.hardNavigationTarget;
-					return;
-				}
-				const redirectDecision = resolveRscRedirectLifecycleHop({
-					currentHref,
-					historyUpdateMode: currentHistoryMode ?? "replace",
-					origin: window.location.origin,
-					redirectDepth: redirectCount,
-					requestPreviousNextUrl,
-					responseUrl: navResponseUrl ?? navResponse.url
-				});
-				if (redirectDecision.kind === "terminal-hard-navigation") {
-					if (redirectDecision.reason === "maxRedirectsExceeded") console.error("[vinext] Too many RSC redirects — aborting navigation to prevent infinite loop.");
-					window.location.href = redirectDecision.href;
+					cacheBufferPromise.then((cacheBuffer) => {
+						storeVisitedResponseSnapshot(rscUrl, resolveVisitedResponseInterceptionContext(requestInterceptionContext, metadata.interceptionContext), createCachedRscResponseSnapshot(navResponse, cacheBuffer, navResponseUrl), navParams);
+					}).catch(() => {});
 					return;
 				}
-				if (redirectDecision.kind === "follow") {
-					currentHref = redirectDecision.href;
-					currentHistoryMode = redirectDecision.historyUpdateMode;
-					currentPrevNextUrl = redirectDecision.previousNextUrl;
-					redirectCount = redirectDecision.redirectDepth;
-					continue;
-				}
-				const navParams = parseEncodedJsonHeader(navResponse.headers.get("X-Vinext-Params")) ?? {};
-				const navigationSnapshot = createClientNavigationRenderSnapshot(currentHref, navParams);
-				const navBody = navResponse.body;
-				if (!navBody) return;
-				const [reactBranch, cacheBranch] = navBody.tee();
-				const reactResponse = new Response(reactBranch, {
-					status: navResponse.status,
-					headers: navResponse.headers
-				});
-				const cacheBufferPromise = new Response(cacheBranch).arrayBuffer();
-				if (!browserNavigationController.isCurrentNavigation(navId)) return;
-				const rscPayload = decodeAppElementsPromise(createFromFetch(Promise.resolve(reactResponse)));
-				if (!browserNavigationController.isCurrentNavigation(navId)) return;
-				if (await renderNavigationPayload(rscPayload, navigationSnapshot, currentHref, navId, currentHistoryMode, navParams, requestPreviousNextUrl, pendingRouterState, toActionType(navigationKind), toOperationLane(navigationKind), activeTraversalIntent) !== "committed") return;
+			} catch (error) {
 				if (!browserNavigationController.isCurrentNavigation(navId)) return;
-				const resolvedElements = await rscPayload;
-				const metadata = AppElementsWire.readMetadata(resolvedElements);
-				const cacheBuffer = await cacheBufferPromise;
-				storeVisitedResponseSnapshot(rscUrl, resolveVisitedResponseInterceptionContext(requestInterceptionContext, metadata.interceptionContext), createCachedRscResponseSnapshot(navResponse, cacheBuffer, navResponseUrl), navParams);
-				return;
+				if (!isPageUnloading) console.error("[vinext] RSC navigation error:", error);
+				browserNavigationController.performHardNavigation(currentHref);
+			} finally {
+				browserNavigationController.finalizeNavigation(navId, pendingRouterState);
+				discardedServerActionRefreshScheduler.markNavigationSettled();
 			}
-		} catch (error) {
-			if (!browserNavigationController.isCurrentNavigation(navId)) return;
-			if (!isPageUnloading) console.error("[vinext] RSC navigation error:", error);
-			window.location.href = currentHref;
-		} finally {
-			browserNavigationController.finalizeNavigation(navId, pendingRouterState);
-			discardedServerActionRefreshScheduler.markNavigationSettled();
 		}
-	};
+	});
 	if ("scrollRestoration" in history) history.scrollRestoration = "manual";
 	const handlePopstate = createPopstateRestoreHandler({
 		getActiveNavigationId: browserNavigationController.getActiveNavigationId.bind(browserNavigationController),
 		getPendingNavigation: () => window.__VINEXT_RSC_PENDING__,
-		getNavigate: () => window.__VINEXT_RSC_NAVIGATE__,
+		getNavigate: () => getNavigationRuntime()?.functions.navigate,
 		isCurrentNavigation: browserNavigationController.isCurrentNavigation.bind(browserNavigationController),
 		notifyAppRouterTransitionStart: (href) => {
 			notifyAppRouterTransitionStart(href, "traverse");