vinext 0.0.54 → 0.1.0

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

@@ -1,37 +1,40 @@
 import { stripBasePath } from "../utils/base-path.js";
-import { ACTION_REDIRECT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RSC_REDIRECT_HEADER } from "./headers.js";
+import { ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_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 { getMountedSlotIdsHeader, resolveVisitedResponseInterceptionContext } from "./app-elements.js";
+import { AppRouterContext } from "../shims/internal/app-router-context.js";
 import { installWindowNext } from "../client/window-next.js";
-import { scrollToHashTargetOnNextFrame } from "../shims/hash-scroll.js";
+import { retryScrollTo, scrollToHashTargetOnNextFrame } from "../shims/hash-scroll.js";
 import { getNavigationRuntime, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.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 { consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.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 { createHistoryStateWithNavigationMetadata, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, resolveHardNavigationTargetFromRscResponse, resolveRscCompatibilityNavigationDecision } from "./app-rsc-cache-busting.js";
+import { AppBrowserMpaNavigationScheduler } from "./app-browser-mpa-navigation.js";
+import { beginAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
+import { __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, decodeRedirectError, getBfcacheIdMapContext, getClientNavigationRenderContext, getPrefetchCache, invalidatePrefetchCache, isRedirectError, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname, useRouter } from "../shims/navigation.js";
 import { DevRecoveryBoundary, RedirectBoundary } from "../shims/error-boundary.js";
 import { AppRouterScrollCommitProvider } from "../shims/app-router-scroll.js";
-import { ElementsContext, Slot } from "../shims/slot.js";
+import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
 import "../client/instrumentation-client.js";
-import { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, isServerActionResult, parseServerActionRevalidationHeader, resolveServerActionRedirectLocation, shouldClearClientNavigationCachesForServerActionResult } from "./app-browser-action-result.js";
+import { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, resolveServerActionRedirectCompatibilityHardNavigationTarget, shouldCheckRscCompatibilityForServerActionResponse, shouldClearClientNavigationCachesForServerActionResult } from "./app-browser-action-result.js";
+import { createClientReuseManifestHeaderFromVisibleAppState } from "./app-browser-client-reuse-manifest.js";
 import { chunksToReadableStream, createProgressiveRscStream, getVinextBrowserGlobal } from "./app-browser-stream.js";
-import { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, isCacheRestorableAppPayloadMetadata, resolveInterceptionContextFromPreviousNextUrl, resolveServerActionRequestState } from "./app-browser-state.js";
+import { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, 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 { createVisitedResponseCacheEntry, isVisitedResponseCacheEntryFresh } from "./app-visited-response-cache.js";
 import { createPopstateRestoreHandler } from "./app-browser-popstate.js";
 import { createOnUncaughtError } from "./app-browser-error.js";
 import { dismissOverlay } from "./dev-error-overlay-store.js";
-import { devOnCaughtError, devOnUncaughtError, installDevErrorOverlay } from "./dev-error-overlay.js";
+import { devOnCaughtError, devOnUncaughtError, installDevErrorOverlay, installViteHmrErrorHandler, reportInitialDevServerErrors } 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 { removeStylesheetLinksCoveredByInlineCss } from "./app-inline-css-client.js";
-import { createElement, startTransition, use, useLayoutEffect, useRef, useState } from "react";
+import { createElement, startTransition, use, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { createFromFetch, createFromReadableStream, createTemporaryReferenceSet, encodeReply, setServerCallback } from "@vitejs/plugin-rsc/browser";
 import { hydrateRoot } from "react-dom/client";
 //#region src/server/app-browser-entry.ts
@@ -47,8 +50,6 @@ function toOperationLane(kind) {
 	}
 }
 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();
@@ -65,6 +66,17 @@ const discardedServerActionRefreshScheduler = createDiscardedServerActionRefresh
 	getNavigationRuntime()?.functions.navigate?.(window.location.href, 0, "refresh", void 0, void 0, true);
 } });
 const NavigationCommitSignal = browserNavigationController.NavigationCommitSignal;
+const ACTION_HTTP_FALLBACK_ROBOTS_META_ATTR = "data-vinext-action-http-fallback";
+function syncServerActionHttpFallbackHead(status) {
+	document.head.querySelectorAll(`meta[${ACTION_HTTP_FALLBACK_ROBOTS_META_ATTR}="robots"]`).forEach((node) => node.remove());
+	if (status !== 404) return;
+	const robots = document.createElement("meta");
+	robots.name = "robots";
+	robots.content = "noindex";
+	robots.setAttribute(ACTION_HTTP_FALLBACK_ROBOTS_META_ATTR, "robots");
+	document.head.appendChild(robots);
+}
+const BfcacheIdMapContext = getBfcacheIdMapContext();
 function parseEncodedJsonHeader(value) {
 	if (!value) return null;
 	try {
@@ -80,8 +92,30 @@ let latestClientParams = {};
 const visitedResponseCache = /* @__PURE__ */ new Map();
 let browserRouterStateHasEverCommitted = false;
 let pendingNavigationRecoveryHref = null;
+const mpaNavigationScheduler = new AppBrowserMpaNavigationScheduler();
+const unresolvedMpaNavigation = new Promise(() => {});
+const RSC_HMR_SETTLE_DELAY_MS = 150;
+let latestRscHmrUpdateId = 0;
+const initialHistoryBfcacheVersion = readHistoryStateBfcacheVersion(window.history.state);
+let currentBfcacheVersion = initialHistoryBfcacheVersion === null ? 0 : initialHistoryBfcacheVersion + 1;
 let currentHistoryTraversalIndex = readHistoryStateTraversalIndex(window.history.state) ?? 0;
 let nextHistoryTraversalIndex = currentHistoryTraversalIndex;
+function isCurrentBfcacheVersion(state) {
+	return isHistoryStateBfcacheVersionCurrent(state, currentBfcacheVersion);
+}
+function waitForRscHmrSettle(delayMs = RSC_HMR_SETTLE_DELAY_MS) {
+	return new Promise((resolve) => {
+		window.setTimeout(resolve, delayMs);
+	});
+}
+function readCurrentBfcacheVersionHistoryIds(state) {
+	const ids = readHistoryStateBfcacheIds(state);
+	if (ids === null) return null;
+	return isCurrentBfcacheVersion(state) ? ids : null;
+}
+function invalidateRestorableBfcacheIds() {
+	currentBfcacheVersion += 1;
+}
 function allocateNavigationHistoryTraversalIndex(historyUpdateMode) {
 	switch (historyUpdateMode) {
 		case "push": return nextHistoryTraversalIndex + 1;
@@ -97,7 +131,10 @@ function commitHistoryTraversalIndex(index) {
 function commitHashOnlyNavigation(href, historyUpdateMode, scroll) {
 	const navigationHistoryIndex = allocateNavigationHistoryTraversalIndex(historyUpdateMode);
 	const previousNextUrl = hasBrowserRouterState() ? getBrowserRouterState().previousNextUrl : readHistoryStatePreviousNextUrl(window.history.state);
+	const bfcacheIds = hasBrowserRouterState() ? getBrowserRouterState().bfcacheIds : readCurrentBfcacheVersionHistoryIds(window.history.state);
 	const historyState = createHistoryStateWithNavigationMetadata(createHashOnlyNavigationBaseHistoryState(historyUpdateMode, scroll), {
+		bfcacheIds,
+		bfcacheVersion: bfcacheIds === null ? void 0 : currentBfcacheVersion,
 		previousNextUrl,
 		traversalIndex: navigationHistoryIndex
 	});
@@ -153,6 +190,7 @@ function clearPrefetchState() {
 function clearClientNavigationCaches() {
 	clearVisitedResponseCache();
 	clearPrefetchState();
+	invalidateRestorableBfcacheIds();
 }
 function isSettledPrefetchCacheEntry(entry) {
 	return entry.outcome === "cache-seeded" && entry.pending === void 0 && entry.snapshot !== void 0;
@@ -171,7 +209,7 @@ function parsePrefetchCacheKey(cacheKey) {
 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 (resolvePrefetchCacheEntryMountedSlotsHeader(options.entry) !== options.mountedSlotsHeader) return false;
 	if (options.interceptionContext !== null) return false;
 	const elements = await decodeAppElementsPromise(createFromFetch(Promise.resolve(restoreRscResponse(options.entry.snapshot))));
 	const template = createOptimisticRouteTemplate({
@@ -220,11 +258,26 @@ async function learnOptimisticRouteTemplatesFromPrefetchCache(options) {
 	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);
+function areBfcacheIdMapsEqual(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null) return false;
+	const aEntries = Object.entries(a);
+	const bEntries = Object.entries(b);
+	if (aEntries.length !== bEntries.length) return false;
+	return aEntries.every(([key, value]) => b[key] === value);
+}
+function isHistoryStateNavigationMetadataInSync(state, previousNextUrl, bfcacheIds) {
+	return readHistoryStatePreviousNextUrl(state) === previousNextUrl && (bfcacheIds === void 0 || areBfcacheIdMapsEqual(readHistoryStateBfcacheIds(state), bfcacheIds) && isCurrentBfcacheVersion(state));
+}
+function syncCurrentHistoryStatePreviousNextUrl(previousNextUrl, bfcacheIds) {
+	if (isHistoryStateNavigationMetadataInSync(window.history.state, previousNextUrl, bfcacheIds)) return;
+	const nextHistoryState = createHistoryStateWithNavigationMetadata(window.history.state, {
+		bfcacheIds,
+		bfcacheVersion: bfcacheIds === void 0 ? void 0 : currentBfcacheVersion,
+		previousNextUrl
+	});
 	replaceHistoryStateWithoutNotify(nextHistoryState, "", window.location.href);
-	if (readHistoryStatePreviousNextUrl(window.history.state) === previousNextUrl) return;
+	if (isHistoryStateNavigationMetadataInSync(window.history.state, previousNextUrl, bfcacheIds)) return;
 	window.history.replaceState(nextHistoryState, "", window.location.href);
 }
 function createActionInitiationSnapshot() {
@@ -236,7 +289,7 @@ function createActionInitiationSnapshot() {
 	});
 }
 function createNavigationCommitEffect(options) {
-	const { href, historyUpdateMode, navId, params, previousNextUrl, targetHistoryIndex } = options;
+	const { bfcacheIds, href, historyUpdateMode, navId, params, previousNextUrl, targetHistoryIndex } = options;
 	return () => {
 		if (!browserNavigationController.isCurrentNavigation(navId)) {
 			commitClientNavigationState(void 0, { releaseSnapshot: true });
@@ -246,6 +299,8 @@ function createNavigationCommitEffect(options) {
 		const preserveExistingState = historyUpdateMode === "replace";
 		const navigationHistoryIndex = targetHistoryIndex !== void 0 ? targetHistoryIndex : allocateNavigationHistoryTraversalIndex(historyUpdateMode);
 		const historyState = createHistoryStateWithNavigationMetadata(preserveExistingState ? window.history.state : null, {
+			bfcacheIds,
+			bfcacheVersion: currentBfcacheVersion,
 			previousNextUrl,
 			traversalIndex: navigationHistoryIndex
 		});
@@ -262,7 +317,7 @@ function createNavigationCommitEffect(options) {
 			commitHistoryTraversalIndex(navigationHistoryIndex);
 		}
 		if (!wroteHistoryState) {
-			syncCurrentHistoryStatePreviousNextUrl(previousNextUrl);
+			syncCurrentHistoryStatePreviousNextUrl(previousNextUrl, bfcacheIds);
 			stageClientParams(params);
 			if (targetHistoryIndex !== void 0) commitHistoryTraversalIndex(targetHistoryIndex);
 		}
@@ -270,7 +325,8 @@ 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) {
+async function renderNavigationPayload(payload, navigationSnapshot, targetHref, navId, historyUpdateMode, params, previousNextUrl, pendingRouterState, payloadOrigin, actionType = "navigate", operationLane = "navigation", traversalIntent = null, scrollIntent = null, restoredBfcacheIds = null) {
+	syncServerActionHttpFallbackHead(null);
 	try {
 		return await browserNavigationController.renderNavigationPayload({
 			actionType,
@@ -287,6 +343,7 @@ async function renderNavigationPayload(payload, navigationSnapshot, targetHref,
 			pendingRouterState,
 			previousNextUrl,
 			scrollIntent,
+			restoredBfcacheIds,
 			targetHistoryIndex: traversalIntent === null ? void 0 : traversalIntent.targetHistoryIndex,
 			targetHref,
 			navId
@@ -296,6 +353,52 @@ async function renderNavigationPayload(payload, navigationSnapshot, targetHref,
 		throw error;
 	}
 }
+function resolveActionRedirectTarget(response) {
+	const actionRedirect = response.headers.get(ACTION_REDIRECT_HEADER);
+	if (!actionRedirect) return null;
+	if (isDangerousScheme(actionRedirect)) {
+		console.error(DANGEROUS_URL_BLOCK_MESSAGE);
+		return null;
+	}
+	try {
+		let redirectUrl;
+		if (actionRedirect.startsWith("/") || /^[a-z]+:/i.test(actionRedirect)) redirectUrl = new URL(actionRedirect, window.location.href);
+		else {
+			const baseParsed = new URL(window.location.href);
+			let baseDir = baseParsed.pathname;
+			if (!baseDir.endsWith("/")) baseDir = baseDir + "/";
+			redirectUrl = new URL(actionRedirect, `${baseParsed.origin}${baseDir}${baseParsed.search}`);
+		}
+		if (redirectUrl.origin !== window.location.origin) {
+			browserNavigationController.performHardNavigation(actionRedirect);
+			return null;
+		}
+		const statusHeader = response.headers.get(ACTION_REDIRECT_STATUS_HEADER);
+		const status = statusHeader ? parseInt(statusHeader, 10) : 307;
+		return {
+			href: redirectUrl.href,
+			type: response.headers.get("x-action-redirect-type") ?? "push",
+			status
+		};
+	} catch {
+		browserNavigationController.performHardNavigation(actionRedirect);
+		return null;
+	}
+}
+var ServerActionRedirectError = class extends Error {
+	digest;
+	handled = true;
+	constructor(target) {
+		super("NEXT_REDIRECT");
+		const redirectUrl = new URL(target.href, window.location.href);
+		const redirectHref = redirectUrl.pathname + redirectUrl.search + redirectUrl.hash;
+		const redirectType = target.type === "push" ? "push" : "replace";
+		this.digest = `NEXT_REDIRECT;${redirectType};${encodeURIComponent(redirectHref)};${target.status};`;
+	}
+};
+function createServerActionRedirectError(target) {
+	return new ServerActionRedirectError(target);
+}
 async function commitSameUrlNavigatePayload(nextElements, actionInitiation, returnValue, revalidation = "none") {
 	const navigationSnapshot = createClientNavigationRenderSnapshot(actionInitiation.href, actionInitiation.routerState.navigationSnapshot.params);
 	return browserNavigationController.commitSameUrlNavigatePayload(nextElements, navigationSnapshot, returnValue, actionInitiation.routerState, {
@@ -322,18 +425,10 @@ function getVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, nav
 		visitedResponseCache.delete(cacheKey);
 		return null;
 	}
-	if (navigationKind === "refresh") return null;
-	if (navigationKind === "traverse") {
-		const createdAt = cached.expiresAt - VISITED_RESPONSE_CACHE_TTL;
-		if (Date.now() - createdAt >= MAX_TRAVERSAL_CACHE_TTL) {
-			visitedResponseCache.delete(cacheKey);
-			return null;
-		}
-		visitedResponseCache.delete(cacheKey);
-		visitedResponseCache.set(cacheKey, cached);
-		return cached;
-	}
-	if (cached.expiresAt > Date.now()) {
+	if (isVisitedResponseCacheEntryFresh(cached, {
+		navigationKind,
+		now: Date.now()
+	})) {
 		visitedResponseCache.delete(cacheKey);
 		visitedResponseCache.set(cacheKey, cached);
 		return cached;
@@ -341,16 +436,23 @@ function getVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, nav
 	visitedResponseCache.delete(cacheKey);
 	return null;
 }
+function deleteVisitedResponse(rscUrl, interceptionContext) {
+	visitedResponseCache.delete(AppElementsWire.encodeCacheKey(rscUrl, interceptionContext));
+}
 function storeVisitedResponseSnapshot(rscUrl, interceptionContext, snapshot, params) {
 	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 	visitedResponseCache.delete(cacheKey);
 	evictVisitedResponseCacheIfNeeded();
 	const now = Date.now();
-	visitedResponseCache.set(cacheKey, {
+	visitedResponseCache.set(cacheKey, createVisitedResponseCacheEntry({
+		now,
 		params,
-		expiresAt: now + VISITED_RESPONSE_CACHE_TTL,
 		response: snapshot
-	});
+	}));
+}
+function isSamePageSearchNavigation(currentSnapshot, targetUrl) {
+	if (stripBasePath(targetUrl.pathname, __basePath) !== currentSnapshot.pathname) return false;
+	return targetUrl.searchParams.toString() !== currentSnapshot.searchParams.toString();
 }
 function getRequestState(navigationKind, targetPathname, previousNextUrlOverride, traverseHistoryState) {
 	if (previousNextUrlOverride !== void 0) return {
@@ -399,14 +501,44 @@ function getRequestState(navigationKind, targetPathname, previousNextUrlOverride
 function handleDevRecoveryBoundaryCatch(resetKey) {
 	browserNavigationController.drainPrePaintEffects(resetKey);
 }
+function isMpaNavigationState(value) {
+	return value !== null && typeof value === "object" && "kind" in value && value.kind === "mpa-navigation";
+}
+function performMpaNavigation(href, historyUpdateMode) {
+	mpaNavigationScheduler.navigate(window, href, historyUpdateMode);
+}
+function AppRouterRedirectBridge({ children }) {
+	const router = useRouter();
+	useEffect(() => {
+		const handleUnhandledRedirect = (event) => {
+			const error = "reason" in event ? event.reason : event.error;
+			if (!isRedirectError(error)) return;
+			const result = decodeRedirectError(error.digest);
+			if (!result) return;
+			event.preventDefault();
+			startTransition(() => {
+				if (result.type === "push") router.push(result.url);
+				else router.replace(result.url);
+			});
+		};
+		window.addEventListener("error", handleUnhandledRedirect);
+		window.addEventListener("unhandledrejection", handleUnhandledRedirect);
+		return () => {
+			window.removeEventListener("error", handleUnhandledRedirect);
+			window.removeEventListener("unhandledrejection", handleUnhandledRedirect);
+		};
+	}, [router]);
+	return children ?? null;
+}
 function decodeAppElementsPromise(payload) {
 	return Promise.resolve(payload).then((elements) => AppElementsWire.decode(elements));
 }
 function BrowserRoot({ initialElements, initialNavigationSnapshot }) {
 	const resolvedElements = use(initialElements);
 	const initialMetadata = AppElementsWire.readMetadata(resolvedElements);
-	const [treeStateValue, setTreeStateValue] = useState({
+	const [treeStateValue, setTreeStateValue] = useState(() => ({
 		activeOperation: null,
+		bfcacheIds: createInitialBfcacheIdMap(resolvedElements),
 		elements: resolvedElements,
 		interception: initialMetadata.interception,
 		interceptionContext: initialMetadata.interceptionContext,
@@ -419,12 +551,27 @@ function BrowserRoot({ initialElements, initialNavigationSnapshot }) {
 		routeId: initialMetadata.routeId,
 		slotBindings: initialMetadata.slotBindings,
 		visibleCommitVersion: 0
-	});
+	}));
+	if (isMpaNavigationState(treeStateValue)) {
+		performMpaNavigation(treeStateValue.href, treeStateValue.historyUpdateMode);
+		throw unresolvedMpaNavigation;
+	}
 	const treeState = isRouterStatePromise(treeStateValue) ? use(treeStateValue) : treeStateValue;
 	const stateRef = useRef(treeState);
 	stateRef.current = treeState;
 	useLayoutEffect(() => {
-		const detach = browserNavigationController.attachBrowserRouterState(setTreeStateValue, stateRef);
+		const setAppRouterStateValue = (value) => {
+			setTreeStateValue(value);
+		};
+		const detach = browserNavigationController.attachBrowserRouterState(setAppRouterStateValue, stateRef);
+		registerNavigationRuntimeFunctions({ navigateExternal: (href, historyUpdateMode) => {
+			setTreeStateValue({
+				href,
+				historyUpdateMode,
+				kind: "mpa-navigation"
+			});
+			return new Promise(() => {});
+		} });
 		browserRouterStateHasEverCommitted = true;
 		const hydratedAt = performance.now();
 		window.__VINEXT_HYDRATED_AT = hydratedAt;
@@ -432,6 +579,7 @@ function BrowserRoot({ initialElements, initialNavigationSnapshot }) {
 		window.__NEXT_HYDRATED_AT = hydratedAt;
 		window.__NEXT_HYDRATED_CB?.();
 		return () => {
+			registerNavigationRuntimeFunctions({ navigateExternal: void 0 });
 			detach();
 			setMountedSlotsHeader(null);
 		};
@@ -444,12 +592,24 @@ function BrowserRoot({ initialElements, initialNavigationSnapshot }) {
 	useLayoutEffect(() => {
 		if (treeState.renderId !== 0) return;
 		replaceHistoryStateWithoutNotify(createHistoryStateWithNavigationMetadata(window.history.state, {
+			bfcacheIds: treeState.bfcacheIds,
+			bfcacheVersion: currentBfcacheVersion,
 			previousNextUrl: treeState.previousNextUrl,
 			traversalIndex: currentHistoryTraversalIndex
 		}), "", window.location.href);
-	}, [treeState.previousNextUrl, treeState.renderId]);
+	}, [
+		treeState.bfcacheIds,
+		treeState.previousNextUrl,
+		treeState.renderId
+	]);
 	const routeTree = createElement(RedirectBoundary, null, createElement(NavigationCommitSignal, { renderId: treeState.renderId }, createElement(ElementsContext.Provider, { value: treeState.elements }, createElement(Slot, { id: treeState.routeId }))));
-	const innerTree = AppRouterContext ? createElement(AppRouterContext.Provider, { value: appRouterInstance }, routeTree) : routeTree;
+	const bfcacheStateKeys = useMemo(() => createBfcacheSegmentStateKeyMap({
+		elements: treeState.elements,
+		pathname: treeState.navigationSnapshot.pathname
+	}), [treeState.elements, treeState.navigationSnapshot.pathname]);
+	const stateKeyTree = createElement(BfcacheStateKeyMapContext.Provider, { value: bfcacheStateKeys }, routeTree);
+	const redirectedTree = createElement(AppRouterRedirectBridge, null, BfcacheIdMapContext ? createElement(BfcacheIdMapContext.Provider, { value: treeState.bfcacheIds }, stateKeyTree) : stateKeyTree);
+	const innerTree = AppRouterContext ? createElement(AppRouterContext.Provider, { value: appRouterInstance }, redirectedTree) : redirectedTree;
 	const committedTree = import.meta.env.DEV ? createElement(DevRecoveryBoundary, {
 		resetKey: treeState.renderId,
 		onCatch: handleDevRecoveryBoundaryCatch
@@ -466,16 +626,15 @@ function restoreHydrationNavigationContext(pathname, searchParams, params) {
 		params
 	});
 }
-function restorePopstateScrollPosition(state) {
+function restorePopstateScrollPosition(state, options) {
+	const shouldContinue = options?.shouldContinue ?? (() => true);
+	if (!shouldContinue()) return;
 	if (!(state && typeof state === "object" && "__vinext_scrollY" in state)) {
 		if (window.location.hash) scrollToHashTargetOnNextFrame(window.location.hash);
 		return;
 	}
 	const y = Number(state.__vinext_scrollY);
-	const x = "__vinext_scrollX" in state ? Number(state.__vinext_scrollX) : 0;
-	requestAnimationFrame(() => {
-		window.scrollTo(x, y);
-	});
+	retryScrollTo("__vinext_scrollX" in state ? Number(state.__vinext_scrollX) : 0, y, { shouldContinue });
 }
 function isSameAppRoutePopstateTarget(href) {
 	if (!hasBrowserRouterState()) return false;
@@ -566,9 +725,10 @@ function applyRuntimeRscBootstrap(rsc) {
 }
 function registerServerActionCallback() {
 	setServerCallback(async (id, args) => {
+		syncServerActionHttpFallbackHead(null);
 		const temporaryReferences = createTemporaryReferenceSet();
 		const actionInitiation = createActionInitiationSnapshot();
-		syncCurrentHistoryStatePreviousNextUrl(actionInitiation.routerState.previousNextUrl);
+		syncCurrentHistoryStatePreviousNextUrl(actionInitiation.routerState.previousNextUrl, actionInitiation.routerState.bfcacheIds);
 		const body = await encodeReply(args, { temporaryReferences });
 		const { headers } = resolveServerActionRequestState({
 			actionId: id,
@@ -576,39 +736,26 @@ function registerServerActionCallback() {
 			elements: actionInitiation.routerState.elements,
 			previousNextUrl: actionInitiation.routerState.previousNextUrl
 		});
-		const fetchResponse = await fetch(await createRscRequestUrl(actionInitiation.path, headers), {
+		const fetchResponse = await fetch(createServerActionRequestUrl(actionInitiation.path), {
 			method: "POST",
 			headers,
 			body
 		});
 		throwOnServerActionNotFound(fetchResponse, id);
-		const actionRedirect = fetchResponse.headers.get(ACTION_REDIRECT_HEADER);
-		if (actionRedirect) {
-			if (isDangerousScheme(actionRedirect)) {
-				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 {
-				redirectLocation = resolveServerActionRedirectLocation({
-					currentHref: actionInitiation.href,
-					location: actionRedirect,
-					origin: window.location.origin
-				});
-			} catch {
-				clearClientNavigationCaches();
-				browserNavigationController.performHardNavigation(actionRedirect, hardNavigationMode);
-				return;
-			}
+		const hasActionRedirect = fetchResponse.headers.has(ACTION_REDIRECT_HEADER);
+		const actionRedirectTarget = resolveActionRedirectTarget(fetchResponse);
+		if (hasActionRedirect && !actionRedirectTarget) return;
+		const actionRedirectCompatibilityHardNavigationTarget = resolveServerActionRedirectCompatibilityHardNavigationTarget({
+			actionRedirectHref: actionRedirectTarget?.href ?? null,
+			clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
+			response: fetchResponse
+		});
+		if (actionRedirectCompatibilityHardNavigationTarget) {
 			clearClientNavigationCaches();
-			startTransition(() => {
-				navigateClientSide(redirectLocation.href, historyUpdateMode, true, true);
-			});
+			browserNavigationController.performHardNavigation(actionRedirectCompatibilityHardNavigationTarget, actionRedirectTarget?.type === "push" ? "assign" : "replace");
 			return;
 		}
-		if (resolveRscCompatibilityNavigationDecision({
+		if (!actionRedirectTarget && shouldCheckRscCompatibilityForServerActionResponse(fetchResponse) && resolveRscCompatibilityNavigationDecision({
 			clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
 			currentHref: actionInitiation.href,
 			origin: window.location.origin,
@@ -619,12 +766,44 @@ function registerServerActionCallback() {
 			return;
 		}
 		const revalidation = parseServerActionRevalidationHeader(fetchResponse.headers);
-		const result = await createFromFetch(Promise.resolve(fetchResponse), { temporaryReferences });
+		const invalidResponseError = await readInvalidServerActionResponseError(fetchResponse.clone(), actionRedirectTarget !== null);
+		if (invalidResponseError) throw invalidResponseError;
+		if (actionRedirectTarget && !shouldCheckRscCompatibilityForServerActionResponse(fetchResponse)) {
+			browserNavigationController.performHardNavigation(actionRedirectTarget.href);
+			return;
+		}
+		const flightResponse = fetchResponse.status === 303 ? new Response(fetchResponse.body, {
+			headers: fetchResponse.headers,
+			status: 200,
+			statusText: "OK"
+		}) : fetchResponse;
+		const result = await createFromFetch(Promise.resolve(flightResponse), { temporaryReferences });
 		if (shouldClearClientNavigationCachesForServerActionResult(result, revalidation)) clearClientNavigationCaches();
+		if (actionRedirectTarget) {
+			if (isServerActionResult(result) && result.root !== void 0) {
+				const decoded = AppElementsWire.decode(result.root);
+				const hashIdx = actionRedirectTarget.href.indexOf("#");
+				const actionScrollIntent = beginAppRouterScrollIntent((hashIdx !== -1 ? actionRedirectTarget.href.slice(hashIdx) : "") || null);
+				if (actionRedirectTarget.type === "push") saveScrollPosition();
+				renderNavigationPayload(Promise.resolve(decoded), createClientNavigationRenderSnapshot(actionRedirectTarget.href, actionInitiation.routerState.navigationSnapshot.params), actionRedirectTarget.href, actionInitiation.navigationId, actionRedirectTarget.type === "push" ? "push" : "replace", {}, null, null, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, actionRedirectTarget.type === "push" ? "navigate" : "replace", "server-action", null, actionScrollIntent).catch(() => {
+					browserNavigationController.performHardNavigation(actionRedirectTarget.href);
+				});
+				throw createServerActionRedirectError(actionRedirectTarget);
+			}
+			browserNavigationController.performHardNavigation(actionRedirectTarget.href);
+			return;
+		}
+		syncServerActionHttpFallbackHead(isServerActionResult(result) && result.root !== void 0 ? null : fetchResponse.status);
 		if (isServerActionResult(result)) {
-			if (result.root !== void 0) return commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result.root)), actionInitiation, result.returnValue, revalidation);
+			if (result.root !== void 0) {
+				const returnValue = result.returnValue && !result.returnValue.ok ? {
+					ok: false,
+					data: normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status)
+				} : result.returnValue;
+				return commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result.root)), actionInitiation, returnValue, revalidation);
+			}
 			if (result.returnValue) {
-				if (!result.returnValue.ok) throw result.returnValue.data;
+				if (!result.returnValue.ok) throw normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status);
 				return result.returnValue.data;
 			}
 			return;
@@ -634,12 +813,16 @@ function registerServerActionCallback() {
 }
 async function main() {
 	registerServerActionCallback();
+	if (import.meta.env.DEV) {
+		installDevErrorOverlay();
+		installViteHmrErrorHandler(import.meta.hot);
+		reportInitialDevServerErrors();
+	}
 	const rscStream = await readInitialRscStream();
 	if (rscStream === null) return;
 	bootstrapHydration(rscStream);
 }
 function bootstrapHydration(rscStream) {
-	if (import.meta.env.DEV) installDevErrorOverlay();
 	const root = decodeAppElementsPromise(createFromReadableStream(rscStream));
 	const initialNavigationSnapshot = createClientNavigationRenderSnapshot(window.location.href, latestClientParams);
 	replaceHistoryStateWithoutNotify(createHistoryStateWithNavigationMetadata(window.history.state, {
@@ -686,6 +869,7 @@ function bootstrapHydration(rscStream) {
 				consumeAppRouterScrollIntent(scrollIntent ?? null);
 				return browserNavigationController.performHardNavigation(targetHref);
 			};
+			let restoredBfcacheIds = navigationKind === "traverse" ? readCurrentBfcacheVersionHistoryIds(activeTraversalIntent?.historyState ?? window.history.state) : null;
 			try {
 				const shouldUsePendingRouterState = programmaticTransition;
 				if (shouldUsePendingRouterState && hasBrowserRouterState()) pendingRouterState = beginPendingBrowserRouterState();
@@ -699,17 +883,19 @@ function bootstrapHydration(rscStream) {
 					const requestState = getRequestState(navigationKind, url.pathname, currentPrevNextUrl, activeTraversalIntent?.historyState);
 					const requestInterceptionContext = requestState.interceptionContext;
 					const requestPreviousNextUrl = requestState.previousNextUrl;
-					if (navigationKind === "refresh") syncCurrentHistoryStatePreviousNextUrl(requestPreviousNextUrl);
+					if (navigationKind === "refresh") syncCurrentHistoryStatePreviousNextUrl(requestPreviousNextUrl, getBrowserRouterState().bfcacheIds);
 					setPendingPathname(url.pathname, navId);
-					const elementsAtNavStart = getBrowserRouterState().elements;
+					const routerStateAtNavStart = getBrowserRouterState();
+					const elementsAtNavStart = routerStateAtNavStart.elements;
 					const mountedSlotsHeader = getMountedSlotIdsHeader(elementsAtNavStart);
+					const shouldBypassNavigationCache = navigationKind === "navigate" && isSamePageSearchNavigation(routerStateAtNavStart.navigationSnapshot, url);
 					const requestHeaders = createRscRequestHeaders({
 						interceptionContext: requestInterceptionContext,
+						mountedSlotsHeader,
 						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);
+					const cachedRoute = shouldBypassNavigationCache ? null : getVisitedResponse(rscUrl, requestInterceptionContext, mountedSlotsHeader, navigationKind);
 					if (cachedRoute) {
 						const compatibilityDecision = resolveRscCompatibilityNavigationDecision({
 							clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
@@ -722,20 +908,47 @@ function bootstrapHydration(rscStream) {
 							performHardNavigationForScrollIntent(compatibilityDecision.hardNavigationTarget);
 							return;
 						}
+						const cachedRedirectDecision = resolveRscRedirectLifecycleHop({
+							currentHref,
+							historyUpdateMode: currentHistoryMode ?? "replace",
+							origin: window.location.origin,
+							redirectDepth: redirectCount,
+							requestPreviousNextUrl,
+							responseUrl: cachedRoute.response.url
+						});
+						if (cachedRedirectDecision.kind === "terminal-hard-navigation") {
+							if (cachedRedirectDecision.reason === "maxRedirectsExceeded") console.error("[vinext] Too many RSC redirects — aborting navigation to prevent infinite loop.");
+							performHardNavigationForScrollIntent(cachedRedirectDecision.href);
+							return;
+						}
+						if (cachedRedirectDecision.kind === "follow") {
+							if (navigationKind === "traverse") restoredBfcacheIds = null;
+							currentHref = cachedRedirectDecision.href;
+							currentHistoryMode = cachedRedirectDecision.historyUpdateMode;
+							currentPrevNextUrl = cachedRedirectDecision.previousNextUrl;
+							redirectCount = cachedRedirectDecision.redirectDepth;
+							continue;
+						}
 						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, scrollIntent);
+						if (await renderNavigationPayload(cachedPayload, cachedNavigationSnapshot, currentHref, navId, currentHistoryMode, cachedParams, requestPreviousNextUrl, detachedNavigationCommits ? null : pendingRouterState, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, toActionType(navigationKind), toOperationLane(navigationKind), activeTraversalIntent, scrollIntent, restoredBfcacheIds) === "no-commit") {
+							deleteVisitedResponse(rscUrl, requestInterceptionContext);
+							continue;
+						}
 						return;
 					}
 					let navResponse;
+					let navResponseExpiresAt;
 					let navResponseUrl = null;
-					if (navigationKind !== "refresh") {
-						const prefetchedResponse = consumePrefetchResponse(rscUrl, requestInterceptionContext, mountedSlotsHeader);
+					if (navigationKind !== "refresh" && !shouldBypassNavigationCache) {
+						const prefetchedResponse = await consumePrefetchResponseForNavigation(rscUrl, requestInterceptionContext, mountedSlotsHeader, { shouldConsume: () => browserNavigationController.isCurrentNavigation(navId) });
+						if (!browserNavigationController.isCurrentNavigation(navId)) return;
 						if (prefetchedResponse) {
 							navResponse = restoreRscResponse(prefetchedResponse, false);
+							navResponseExpiresAt = prefetchedResponse.expiresAt;
 							navResponseUrl = prefetchedResponse.url;
 						}
 					}
@@ -759,16 +972,22 @@ function bootstrapHydration(rscStream) {
 							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).catch((error) => {
+								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).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 (!navResponse) {
+						if (navigationKind === "navigate") {
+							const clientReuseManifestHeader = createClientReuseManifestHeaderFromVisibleAppState(routerStateAtNavStart);
+							if (clientReuseManifestHeader !== null) requestHeaders.set(VINEXT_CLIENT_REUSE_MANIFEST_HEADER, clientReuseManifestHeader);
+						}
+						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) {
@@ -800,6 +1019,7 @@ function bootstrapHydration(rscStream) {
 						return;
 					}
 					if (redirectDecision.kind === "follow") {
+						if (navigationKind === "traverse") restoredBfcacheIds = null;
 						currentHref = redirectDecision.href;
 						currentHistoryMode = redirectDecision.historyUpdateMode;
 						currentPrevNextUrl = redirectDecision.previousNextUrl;
@@ -819,7 +1039,10 @@ function bootstrapHydration(rscStream) {
 							performHardNavigationForScrollIntent(resolvedTarget.href);
 							return;
 						}
+						if (navigationKind === "traverse") restoredBfcacheIds = null;
 						currentHref = `${resolvedTarget.pathname}${resolvedTarget.search}${resolvedTarget.hash}`;
+						currentHistoryMode = currentHistoryMode ?? "replace";
+						currentPrevNextUrl = requestPreviousNextUrl;
 						redirectCount += 1;
 						continue;
 					}
@@ -836,17 +1059,22 @@ function bootstrapHydration(rscStream) {
 					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, detachedNavigationCommits ? null : pendingRouterState, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, toActionType(navigationKind), toOperationLane(navigationKind), activeTraversalIntent, scrollIntent) !== "committed") return;
+					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) !== "committed") return;
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
-					const resolvedElements = await rscPayload;
-					const metadata = AppElementsWire.readMetadata(resolvedElements);
-					if (!isCacheRestorableAppPayloadMetadata(metadata)) {
-						cacheBufferPromise.catch(() => {});
-						return;
-					}
-					cacheBufferPromise.then((cacheBuffer) => {
-						storeVisitedResponseSnapshot(rscUrl, resolveVisitedResponseInterceptionContext(requestInterceptionContext, metadata.interceptionContext), createCachedRscResponseSnapshot(navResponse, cacheBuffer, navResponseUrl), navParams);
-					}).catch(() => {});
+					try {
+						const renderedElements = await rscPayload;
+						const metadata = AppElementsWire.readMetadata(renderedElements);
+						if (!isCacheRestorableAppPayloadMetadata(metadata)) {
+							cacheBufferPromise.catch(() => {});
+							return;
+						}
+						const cacheBuffer = await cacheBufferPromise;
+						storeVisitedResponseSnapshot(rscUrl, resolveVisitedResponseInterceptionContext(requestInterceptionContext, metadata.interceptionContext), {
+							...createCachedRscResponseSnapshot(navResponse, cacheBuffer, navResponseUrl),
+							...navResponseExpiresAt !== void 0 ? { expiresAt: navResponseExpiresAt } : {},
+							mountedSlotsHeader: getMountedSlotIdsHeader(renderedElements)
+						}, navParams);
+					} catch {}
 					return;
 				}
 			} catch (error) {
@@ -884,25 +1112,35 @@ function bootstrapHydration(rscStream) {
 		handlePopstate(event);
 	});
 	if (import.meta.hot) {
-		const handleRscUpdate = async () => {
+		const applyRscHmrUpdate = async (updateId) => {
+			if (updateId !== latestRscHmrUpdateId) return;
+			if (document.documentElement.id === "__next_error__") {
+				window.location.reload();
+				return;
+			}
+			if (browserRouterStateHasEverCommitted && !browserNavigationController.hasBrowserRouterState()) {
+				window.location.reload();
+				return;
+			}
+			await waitForBrowserRouterStateReady();
+			if (updateId !== latestRscHmrUpdateId) return;
+			if (!browserNavigationController.hasBrowserRouterState()) return;
+			clearClientNavigationCaches();
+			const navigationSnapshot = createClientNavigationRenderSnapshot(window.location.href, latestClientParams);
+			dismissOverlay();
+			const hmrHeaders = createRscRequestHeaders();
+			await browserNavigationController.hmrReplaceTree(decodeAppElementsPromise(createFromFetch(fetch(await createRscRequestUrl(window.location.pathname + window.location.search, hmrHeaders), { headers: hmrHeaders }))), navigationSnapshot);
+		};
+		const handleRscUpdate = async (updateId) => {
 			try {
-				if (browserRouterStateHasEverCommitted && !browserNavigationController.hasBrowserRouterState()) {
-					window.location.reload();
-					return;
-				}
-				await waitForBrowserRouterStateReady();
-				if (!browserNavigationController.hasBrowserRouterState()) return;
-				clearClientNavigationCaches();
-				const navigationSnapshot = createClientNavigationRenderSnapshot(window.location.href, latestClientParams);
-				dismissOverlay();
-				const hmrHeaders = createRscRequestHeaders();
-				await browserNavigationController.hmrReplaceTree(decodeAppElementsPromise(createFromFetch(fetch(await createRscRequestUrl(window.location.pathname + window.location.search, hmrHeaders), { headers: hmrHeaders }))), navigationSnapshot);
+				await waitForRscHmrSettle();
+				await applyRscHmrUpdate(updateId);
 			} catch (error) {
 				console.error("[vinext] RSC HMR error:", error);
 			}
 		};
 		import.meta.hot.on("rsc:update", () => {
-			handleRscUpdate();
+			handleRscUpdate(++latestRscHmrUpdateId);
 		});
 	}
 }
@@ -914,12 +1152,11 @@ if (typeof document !== "undefined") {
 	window.addEventListener("pagehide", () => {
 		isPageUnloading = true;
 	});
-	window.addEventListener("pageshow", () => {
+	window.addEventListener("pageshow", (event) => {
 		isPageUnloading = false;
+		if (event.persisted) mpaNavigationScheduler.reset();
 	});
 	main();
 }
 //#endregion
 export {};
-
-//# sourceMappingURL=app-browser-entry.js.map