vinext 1.2.1 → 1.3.1

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

@@ -14,11 +14,11 @@ import { clearAppNavigationFailureTarget, installAppNavigationFailureListeners }
 import { DevRecoveryBoundary, GlobalErrorBoundary, RedirectBoundary } from "../shims/error-boundary.js";
 import { beginAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { AppRouterScrollCommitProvider } from "../shims/app-router-scroll.js";
-import { BfcacheIdentityMapContext, ElementsContext, Slot, bindAppElementsRenderedSearch, setAppElementsRenderedSearch } from "../shims/slot.js";
-import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, formatRscRequestPath, getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
+import { BfcacheIdentityMapContext, bindAppElementsRenderedSearch, setAppElementsRenderedSearch } from "../shims/slot.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, formatRscRequestPath, isRscCompatibilityIdCompatible } from "./app-rsc-cache-busting.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import "../client/instrumentation-client.js";
-import { getNavigationRuntime, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
+import { createNavigationRuntimeRouteManifestLoader, getNavigationRuntime, loadNavigationRuntimeRouteManifest, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
 import { createBfcacheSegmentIdentityMap, createInitialBfcacheIdMap } from "./app-bfcache-identity.js";
 import { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, resolveServerActionOperationLane } from "./app-browser-action-result.js";
 import { createClientReuseManifestHeaderFromVisibleAppState } from "./app-browser-client-reuse-manifest.js";
@@ -31,7 +31,8 @@ import { navigationPlanner } from "./navigation-planner.js";
 import { DYNAMIC_NAVIGATION_CACHE_TTL, PREFETCH_CACHE_TTL, __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponse, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, deletePrefetchResponseSnapshot, disableNavigationResponsePrefetchCacheReuse, getClientNavigationRenderContext, getMountedSlotsHeader, getPrefetchCache, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, parseRenderedPathAndSearchHeader, 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 { clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch, navigateDocumentDirectly } from "./app-browser-navigation-controller.js";
+import { createAppRouteTree } from "./app-route-tree.js";
 import { shouldRecoverSamePathSearchCommitOnResponseCompletion } from "./app-browser-navigation-response.js";
 import { createSupplementalRefreshCoordinator, mergeRefreshedParallelSlot, requireCompleteSupplementalRefresh, resolvePersistedSourcePageRefreshes, resolveServerActionSupplementalRefresh, resolveSupplementalRefreshes } from "./app-browser-supplemental-refresh.js";
 import { createAppBrowserNavigationAbortCoordinator } from "./app-browser-navigation-abort.js";
@@ -42,7 +43,7 @@ import { createPopstateRestoreHandler, restoreSynchronousPopstateScrollPosition,
 import { createDevOnCaughtError, createOnUncaughtError, createProdOnCaughtError, createProdOnRecoverableError } from "./app-browser-error.js";
 import { createHydrationCachePublication } from "./app-hydration-cache-publication.js";
 import { peekSettledPrefetchResponseForNavigation, prepareConsumedPrefetchResponseForPublication, preserveCommittedPrefetchExpiry, resolvePrefetchNavigationResponseUrl } from "./app-browser-prefetch-response.js";
-import { canCommitOptimisticRouteTemplate, createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, matchOptimisticRouteManifestRoute, resolveOptimisticNavigationParamsForHref, resolveOptimisticNavigationPayload } from "./app-optimistic-routing.js";
+import { canCommitOptimisticRouteTemplate, createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, keepOptimisticStreamingMetadata, resolveOptimisticNavigationParamsForHref, 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";
@@ -64,8 +65,21 @@ function toOperationLane(kind) {
 }
 const MAX_VISITED_RESPONSE_CACHE_SIZE = 50;
 const IS_STATIC_EXPORT = process.env.NODE_ENV === "production" && process.env.__NEXT_CONFIG_OUTPUT === "export";
-const CLIENT_DEPLOYMENT_VERSION = process.env.__VINEXT_BUILD_ID ?? null;
-const CLIENT_RSC_COMPATIBILITY_ID = IS_STATIC_EXPORT ? null : getVinextRscCompatibilityId();
+let clientDeploymentVersion = null;
+let clientRscCompatibilityId = IS_STATIC_EXPORT ? null : "vinext:missing";
+/**
+* Decoding a payload loads the chunks its client references name, so a
+* payload this page can't navigate to is only decoded by the navigation that
+* hard-navigates. Otherwise a prefetch after a deploy would load the new
+* deployment's code and stylesheets into this page.
+*/
+function isRscResponseCompatible(compatibilityIdHeader) {
+	return isRscCompatibilityIdCompatible(compatibilityIdHeader, clientRscCompatibilityId);
+}
+function setClientRscCompatibilityId(compatibilityId) {
+	if (IS_STATIC_EXPORT || !compatibilityId) return;
+	clientRscCompatibilityId = compatibilityId;
+}
 const optimisticRouteTemplates = /* @__PURE__ */ new Map();
 const optimisticRouteTemplateSources = /* @__PURE__ */ new Set();
 const optimisticRouteTemplateLearning = /* @__PURE__ */ new Map();
@@ -77,6 +91,7 @@ function claimInitialAppRouterBootstrap() {
 function markInitialAppRouterBootstrapHydrated() {
 	window.__VINEXT_RSC_BOOTSTRAP_STATE__ = "hydrated";
 }
+registerNavigationRuntimeFunctions({ loadRouteManifest: createNavigationRuntimeRouteManifestLoader(() => import("virtual:vinext-app-route-manifest")) });
 function getBrowserRouteManifest() {
 	return getNavigationRuntime()?.bootstrap.routeManifest ?? null;
 }
@@ -92,7 +107,7 @@ function resolveStaticExportRouteParams(href) {
 function isStaticExportPayloadDeploymentCompatible(elements) {
 	if (!IS_STATIC_EXPORT) return true;
 	const deploymentVersion = AppElementsWire.readMetadata(elements).artifactCompatibility.deploymentVersion;
-	return CLIENT_DEPLOYMENT_VERSION !== null && deploymentVersion === CLIENT_DEPLOYMENT_VERSION;
+	return clientDeploymentVersion !== null && deploymentVersion === clientDeploymentVersion;
 }
 const historyController = new AppBrowserHistoryController({
 	initialHistoryState: window.history.state,
@@ -114,6 +129,14 @@ const historyController = new AppBrowserHistoryController({
 const browserNavigationController = createAppBrowserNavigationController({
 	basePath: __basePath,
 	getRouteManifest: getBrowserRouteManifest,
+	loadRouteManifest: loadNavigationRuntimeRouteManifest,
+	navigateDocument: (href, mode) => {
+		if (mpaNavigationTree) {
+			mpaNavigationTree.enter(href, mode === "replace" ? "replace" : "push");
+			return;
+		}
+		navigateDocumentDirectly(href, mode);
+	},
 	syncHistoryStatePreviousNextUrl: (previousNextUrl, bfcacheIds) => historyController.syncCurrentHistoryStatePreviousNextUrl(previousNextUrl, bfcacheIds)
 });
 const discardedServerActionRefreshScheduler = hasServerActions ? createDiscardedServerActionRefreshScheduler({ runRefresh() {
@@ -126,6 +149,7 @@ const discardedServerActionRefreshScheduler = hasServerActions ? createDiscarded
 };
 const serverActionSupplementalRefreshCoordinator = createSupplementalRefreshCoordinator();
 const NavigationCommitSignal = browserNavigationController.NavigationCommitSignal;
+const NavigationHistoryCommit = browserNavigationController.NavigationHistoryCommit;
 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());
@@ -155,6 +179,20 @@ let browserRouterStateHasEverCommitted = false;
 let initialPrefetchRouterState = null;
 const mpaNavigationScheduler = new AppBrowserMpaNavigationScheduler();
 const unresolvedMpaNavigation = new Promise(() => {});
+let mpaNavigationTree = null;
+let mpaNavigationRestore = null;
+function waitForMpaNavigationRestore() {
+	if (!mpaNavigationRestore) {
+		let resolve = () => {};
+		mpaNavigationRestore = {
+			promise: new Promise((resolvePromise) => {
+				resolve = resolvePromise;
+			}),
+			resolve
+		};
+	}
+	return mpaNavigationRestore.promise;
+}
 const RSC_HMR_SETTLE_DELAY_MS = 150;
 const DEFAULT_GLOBAL_ERROR_COMPONENT = DefaultGlobalError;
 let latestRscHmrUpdateId = 0;
@@ -280,6 +318,10 @@ async function fetchPersistedSourcePageRefresh(options) {
 * read the query the server rendered it with, not the navigation's.
 */
 async function decodeSupplementalRefresh(response, targetPathname) {
+	if (!isRscResponseCompatible(response.headers.get("X-Vinext-RSC-Compatibility-Id"))) {
+		response.body?.cancel().catch(() => {});
+		throw new Error("[vinext] Refreshed another deployment's payload");
+	}
 	const elements = await decodeAppElementsPromise(createFromFetch(Promise.resolve(response)));
 	const renderedPathAndSearch = parseRenderedPathAndSearchHeader(response.headers.get(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER));
 	setAppElementsRenderedSearch(elements, new URL(renderedPathAndSearch ?? targetPathname, window.location.origin).search);
@@ -304,6 +346,7 @@ async function learnOptimisticRouteTemplateFromPrefetch(options) {
 	if (source.interceptionContext !== options.interceptionContext) return false;
 	if (resolvePrefetchCacheEntryMountedSlotsHeader(options.entry) !== options.mountedSlotsHeader) return false;
 	if (options.interceptionContext !== null) return false;
+	if (!isRscResponseCompatible(options.entry.snapshot.compatibilityIdHeader)) return false;
 	const elements = await decodeAppElementsPromise(createFromFetch(Promise.resolve(restoreRscResponse(options.entry.snapshot))));
 	const template = createOptimisticRouteTemplate({
 		allowLoadingShell: options.entry.optimisticRouteShell === true,
@@ -362,22 +405,29 @@ function createActionInitiationSnapshot() {
 }
 function createNavigationCommitEffect(options) {
 	const { activeRoutePaths, bfcacheIds, href, historyUpdateMode, navId, params, previousNextUrl, targetHistoryIndex } = options;
-	return ({ keepCurrentUrl, releaseSnapshot }) => {
-		if (!browserNavigationController.isCurrentNavigation(navId)) {
-			commitClientNavigationState(void 0, { releaseSnapshot });
-			return;
+	let wroteHistory = false;
+	return {
+		writeHistory({ keepCurrentUrl }) {
+			if (!browserNavigationController.isCurrentNavigation(navId)) return;
+			historyController.commitNavigationHistory({
+				activeRoutePaths,
+				bfcacheIds,
+				href,
+				historyUpdateMode: keepCurrentUrl ? void 0 : historyUpdateMode,
+				previousNextUrl,
+				stageClientParams: () => stageClientParams(params),
+				targetHistoryIndex
+			});
+			wroteHistory = true;
+		},
+		publish({ releaseSnapshot }) {
+			if (!wroteHistory) {
+				commitClientNavigationState(void 0, { releaseSnapshot });
+				return;
+			}
+			clearAppNavigationFailureTarget(href);
+			commitClientNavigationState(navId, { releaseSnapshot });
 		}
-		historyController.commitNavigationHistory({
-			activeRoutePaths,
-			bfcacheIds,
-			href,
-			historyUpdateMode: keepCurrentUrl ? void 0 : historyUpdateMode,
-			previousNextUrl,
-			stageClientParams: () => stageClientParams(params),
-			targetHistoryIndex
-		});
-		clearAppNavigationFailureTarget(href);
-		commitClientNavigationState(navId, { releaseSnapshot });
 	};
 }
 async function renderNavigationPayload(options) {
@@ -409,7 +459,16 @@ async function renderNavigationPayload(options) {
 async function commitSameUrlNavigatePayload(nextElements, actionInitiation, returnValue, revalidation = "none", renderedPathAndSearch = null) {
 	let shouldRetrySupplementalRefresh = false;
 	let supplementalHandle = null;
+	let routeManifestLoaded = true;
 	if (revalidation !== "none") {
+		const routeManifestLoad = loadNavigationRuntimeRouteManifest();
+		if (routeManifestLoad !== null) routeManifestLoaded = await routeManifestLoad;
+		if (!routeManifestLoaded && browserNavigationController.isCurrentNavigation(actionInitiation.navigationId)) {
+			browserNavigationController.performHardNavigation(actionInitiation.href);
+			return;
+		}
+	}
+	if (revalidation !== "none" && routeManifestLoaded) {
 		const refreshUrl = new URL(actionInitiation.href);
 		const requestInterceptionContext = resolveInterceptionContextFromPreviousNextUrl(actionInitiation.routerState.previousNextUrl, __basePath);
 		const persistedInterceptions = resolvePersistedRefreshInterceptions(actionInitiation.routerState, getBrowserRouteManifest(), refreshUrl, requestInterceptionContext);
@@ -656,23 +715,40 @@ function BrowserRoot({ hydrationCachePublication, initialElements, initialNaviga
 	const treeState = isRouterStatePromise(treeStateValue) ? use(treeStateValue) : treeStateValue;
 	const stateRef = useRef(treeState);
 	stateRef.current = treeState;
+	const committedStateRef = useRef(treeState);
+	useLayoutEffect(() => {
+		committedStateRef.current = treeState;
+	}, [treeState]);
 	useLayoutEffect(() => {
 		const setAppRouterStateValue = (value) => {
 			setTreeStateValue(value);
 		};
 		const detach = browserNavigationController.attachBrowserRouterState(setAppRouterStateValue, stateRef);
-		registerNavigationRuntimeFunctions({ navigateExternal: (href, historyUpdateMode) => {
-			setTreeStateValue({
-				href,
-				historyUpdateMode,
-				kind: "mpa-navigation"
+		const setMpaNavigationState = (href, historyUpdateMode) => {
+			startTransition(() => {
+				setTreeStateValue({
+					href,
+					historyUpdateMode,
+					kind: "mpa-navigation"
+				});
 			});
-			return new Promise(() => {});
+		};
+		const currentMpaNavigationTree = {
+			enter: setMpaNavigationState,
+			restore() {
+				setTreeStateValue((current) => isMpaNavigationState(current) ? committedStateRef.current : current);
+			}
+		};
+		mpaNavigationTree = currentMpaNavigationTree;
+		registerNavigationRuntimeFunctions({ navigateExternal: (href, historyUpdateMode) => {
+			setMpaNavigationState(href, historyUpdateMode);
+			return waitForMpaNavigationRestore();
 		} });
 		browserRouterStateHasEverCommitted = true;
 		hydrationCachePublication.commit();
 		return () => {
 			hydrationCachePublication.invalidate();
+			if (mpaNavigationTree === currentMpaNavigationTree) mpaNavigationTree = null;
 			registerNavigationRuntimeFunctions({ navigateExternal: void 0 });
 			detach();
 			setMountedSlotsHeader(null);
@@ -718,7 +794,11 @@ function BrowserRoot({ hydrationCachePublication, initialElements, initialNaviga
 		treeState.renderId,
 		treeState.slotBindings
 	]);
-	const routeTree = createElement(RedirectBoundary, null, createElement(NavigationCommitSignal, { renderId: treeState.renderId }, createElement(ElementsContext.Provider, { value: treeState.elements }, createElement(Slot, { id: treeState.routeId }))));
+	const routeTree = createElement(RedirectBoundary, null, createElement(NavigationCommitSignal, { renderId: treeState.renderId }, createAppRouteTree({
+		elements: treeState.elements,
+		historyCommit: createElement(NavigationHistoryCommit, { renderId: treeState.renderId }),
+		routeId: treeState.routeId
+	})));
 	const bfcacheSegmentIdentities = useMemo(() => createBfcacheSegmentIdentityMap({ elements: treeState.elements }), [treeState.elements]);
 	const identityMapTree = createElement(BfcacheIdentityMapContext.Provider, { value: bfcacheSegmentIdentities }, routeTree);
 	const bfcacheTree = BfcacheIdMapContext ? createElement(BfcacheIdMapContext.Provider, { value: treeState.bfcacheIds }, identityMapTree) : identityMapTree;
@@ -863,6 +943,7 @@ async function readInitialRscStream() {
 	if (!rscResponse.body) return recoverFromBadInitialRscResponse("returned empty body");
 	clearReloadFlag();
 	clearHardNavigationLoopGuard();
+	setClientRscCompatibilityId(rscResponse.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER));
 	const parsedParams = parseEncodedJsonHeader(rscResponse.headers.get(VINEXT_PARAMS_HEADER));
 	const params = parsedParams ?? {};
 	if (parsedParams) try {
@@ -873,6 +954,7 @@ async function readInitialRscStream() {
 	return rscResponse.body;
 }
 function applyRuntimeRscBootstrap(rsc) {
+	setClientRscCompatibilityId(rsc.compatibilityId);
 	const params = rsc.params ?? {};
 	if (rsc.params) applyClientParams(rsc.params);
 	if (rsc.nav) restoreEmbeddedHydrationNavigationContext(rsc.nav.pathname, rsc.nav.searchParams, params, rsc.searchParamsFromBrowser === true);
@@ -884,7 +966,7 @@ function registerServerActionCallback() {
 		return loadServerActionClient().then(({ invokeClientServerAction }) => invokeClientServerAction(id, args, actionInitiation, {
 			basePath: __basePath,
 			clearClientNavigationCaches,
-			clientRscCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
+			clientRscCompatibilityId,
 			commitSameUrlNavigatePayload,
 			navigationPlanner,
 			performHardNavigation: (url, historyMode) => browserNavigationController.performHardNavigation(url, historyMode),
@@ -919,6 +1001,7 @@ function registerServerActionCallback() {
 }
 async function main() {
 	if (!claimInitialAppRouterBootstrap()) return;
+	loadNavigationRuntimeRouteManifest();
 	if (hasServerActions) registerServerActionCallback();
 	installAppNavigationFailureListeners();
 	if (HAS_CLIENT_REWRITES) await preloadHybridClientRouteOwner();
@@ -939,27 +1022,28 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 	const cacheGeneration = clientNavigationCacheGeneration;
 	const [reactBranch, cacheBranch] = rscStream.tee();
 	const initialNavigationSnapshot = withLateRenderedSearch(createClientNavigationRenderSnapshot(window.location.href, latestClientParams, getHydrationRenderedPathAndSearch()), initialRscBootstrap);
+	const initialPathAndSearch = createSnapshotPathAndSearch(initialNavigationSnapshot);
 	const root = decodeAppElementsPromise(createFromReadableStream(reactBranch)).then((elements) => {
+		if (IS_STATIC_EXPORT) clientDeploymentVersion = AppElementsWire.readMetadata(elements).artifactCompatibility.deploymentVersion;
 		bindAppElementsRenderedSearch(elements, initialNavigationSnapshot);
+		initialPrefetchRouterState = {
+			pathAndSearch: initialPathAndSearch,
+			routeId: AppElementsWire.readMetadata(elements).routeId
+		};
 		return elements;
 	});
 	const initialParams = initialNavigationSnapshot.params;
-	const initialPathAndSearch = createSnapshotPathAndSearch(initialNavigationSnapshot);
 	const initialCacheBuffer = new Response(cacheBranch).arrayBuffer();
 	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 });
 		const rscUrl = await createRscRequestUrl(initialPathAndSearch, headers);
 		if (cacheGeneration !== clientNavigationCacheGeneration) return;
 		const snapshot = {
-			compatibilityIdHeader: CLIENT_RSC_COMPATIBILITY_ID,
+			compatibilityIdHeader: clientRscCompatibilityId,
 			buffer,
 			contentType: VINEXT_RSC_CONTENT_TYPE,
 			...initialRscBootstrap?.dynamicStaleTimeSeconds !== void 0 ? { dynamicStaleTimeSeconds: initialRscBootstrap.dynamicStaleTimeSeconds } : {},
@@ -979,7 +1063,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 		});
 	}).catch(() => {});
 	historyController.writeBootstrapHistoryMetadata();
-	const reportUncaughtError = createOnUncaughtError();
+	const reportUncaughtError = createOnUncaughtError({ coerceToError: import.meta.env.DEV });
 	const onUncaughtError = (...args) => {
 		hydrationCachePublication.fail();
 		reportUncaughtError(...args);
@@ -1029,19 +1113,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 		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;
-			}
+			if (!browserNavigationController.hasBrowserRouterState()) return initialPrefetchRouterState;
 			const state = browserNavigationController.getBrowserRouterState();
 			return {
 				pathAndSearch: createSnapshotPathAndSearch(state.navigationSnapshot),
@@ -1060,11 +1132,21 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 			let currentPrevNextUrl = previousNextUrlOverride;
 			let redirectCount = redirectDepth;
 			let detachedNavigationCommits = false;
+			let optimisticShellElements = null;
+			const keepOptimisticShellMetadata = (payload) => {
+				const shellElements = optimisticShellElements;
+				if (shellElements === null) return payload;
+				return payload instanceof Promise ? payload.then((elements) => keepOptimisticStreamingMetadata(elements, shellElements, String(navId))) : keepOptimisticStreamingMetadata(payload, shellElements, String(navId));
+			};
 			const activeTraversalIntent = navigationKind === "traverse" ? traversalIntent ?? historyController.resolveTraversalIntent(window.history.state) : null;
+			let startedHardNavigation = false;
 			const performHardNavigationForScrollIntent = (targetHref, mode) => {
 				consumeAppRouterScrollIntent(scrollIntent ?? null);
-				const didNavigate = browserNavigationController.performHardNavigation(targetHref, mode);
-				if (!didNavigate) clearAppNavigationFailureTarget(targetHref);
+				const didNavigate = browserNavigationController.performHardNavigation(targetHref, mode ?? (currentHistoryMode === "push" ? "assign" : "replace"));
+				if (didNavigate) {
+					startedHardNavigation = true;
+					browserNavigationController.abandonPendingBrowserRouterState(pendingRouterState);
+				} else clearAppNavigationFailureTarget(targetHref);
 				return didNavigate;
 			};
 			let restoredBfcacheIds = navigationKind === "traverse" ? historyController.readCurrentBfcacheVersionHistoryIds(activeTraversalIntent?.historyState ?? window.history.state) : null;
@@ -1078,6 +1160,15 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
 					if (shouldUsePendingRouterState) pendingRouterState = beginPendingBrowserRouterState();
 				}
+				const routeManifestLoad = loadNavigationRuntimeRouteManifest();
+				if (routeManifestLoad !== null) {
+					const routeManifestLoaded = await routeManifestLoad;
+					if (!browserNavigationController.isCurrentNavigation(navId)) return;
+					if (!routeManifestLoaded) {
+						performHardNavigationForScrollIntent(currentHref);
+						return;
+					}
+				}
 				const navigationInitiationState = getBrowserRouterState();
 				const mountedSlotsHeader = getMountedSlotIdsHeader(navigationInitiationState.elements);
 				while (true) {
@@ -1172,7 +1263,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					});
 					if (reuseDecision.kind === "reuseVisitedResponse" && cachedRoute) {
 						const cachedFetchDecision = navigationPlanner.classifyRscFetchResult({
-							clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
+							clientCompatibilityId: clientRscCompatibilityId,
 							compatibilityIdHeader: cachedRoute.response.compatibilityIdHeader ?? null,
 							currentHref,
 							effectiveHistoryUpdateMode: currentHistoryMode ?? "replace",
@@ -1204,7 +1295,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						const cachedNavigationSnapshot = createClientNavigationRenderSnapshot(currentHref, cachedParams, cachedRoute.response.renderedPathAndSearch);
 						const cachedPayload = cachedRoute.elements ? Promise.resolve(cachedRoute.elements) : decodeAppElementsPromise(createFromFetch(Promise.resolve(restoreRscResponse(cachedRoute.response))));
 						if (!browserNavigationController.isCurrentNavigation(navId)) return;
-						if (await renderNavigationPayload({
+						const cachedRenderOutcome = await renderNavigationPayload({
 							actionType: toActionType(navigationKind),
 							historyUpdateMode: currentHistoryMode,
 							navigationCommitKind: detachedNavigationCommits ? "authoritative" : void 0,
@@ -1213,7 +1304,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 							navId,
 							operationLane: toOperationLane(navigationKind),
 							params: cachedParams,
-							payload: cachedPayload,
+							payload: keepOptimisticShellMetadata(cachedPayload),
 							payloadOrigin: cachedRoute.elements ? COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN : VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN,
 							pendingRouterState: detachedNavigationCommits ? null : pendingRouterState,
 							previousNextUrl: requestPreviousNextUrl,
@@ -1223,7 +1314,12 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 							targetHref: currentHref,
 							traversalIntent: activeTraversalIntent,
 							visibleCommitMode
-						}) === "no-commit") {
+						});
+						if (cachedRenderOutcome === "hard-navigate") {
+							startedHardNavigation = true;
+							browserNavigationController.abandonPendingBrowserRouterState(pendingRouterState);
+						}
+						if (cachedRenderOutcome === "no-commit") {
 							if (!browserNavigationController.isCurrentNavigation(navId)) return;
 							deleteVisitedResponse(rscUrl, requestInterceptionContext);
 							continue;
@@ -1296,6 +1392,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 								template: optimisticPayload.template
 							})) {
 								detachedNavigationCommits = true;
+								optimisticShellElements = optimisticPayload.elements;
 								const optimisticNavigationSnapshot = createClientNavigationRenderSnapshot(currentHref, optimisticPayload.params);
 								renderNavigationPayload({
 									actionType: toActionType(navigationKind),
@@ -1343,7 +1440,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					const streamedRedirectType = streamedRedirectTypeHeader === "push" || streamedRedirectTypeHeader === "replace" ? streamedRedirectTypeHeader : null;
 					if (blockDangerousStreamedRscRedirect(navResponse, streamedRedirectTarget)) return;
 					const liveFetchDecision = navigationPlanner.classifyRscFetchResult({
-						clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
+						clientCompatibilityId: clientRscCompatibilityId,
 						compatibilityIdHeader: navResponse.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER),
 						currentHref,
 						effectiveHistoryUpdateMode: currentHistoryMode ?? "replace",
@@ -1422,7 +1519,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					}
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
 					let committedState = null;
-					if (await renderNavigationPayload({
+					const renderOutcome = await renderNavigationPayload({
 						actionType: toActionType(navigationKind),
 						historyUpdateMode: currentHistoryMode,
 						navigationCommitKind: detachedNavigationCommits ? "authoritative" : void 0,
@@ -1442,7 +1539,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						},
 						operationLane: toOperationLane(navigationKind),
 						params: navParams,
-						payload: rscPayload,
+						payload: keepOptimisticShellMetadata(rscPayload),
 						payloadOrigin: FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN,
 						pendingRouterState: detachedNavigationCommits ? null : pendingRouterState,
 						previousNextUrl: requestPreviousNextUrl,
@@ -1451,8 +1548,13 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						scrollIntent,
 						targetHref: currentHref,
 						traversalIntent: activeTraversalIntent,
-						visibleCommitMode: prefetchedElements ? "synchronous" : visibleCommitMode
-					}) !== "committed") return;
+						visibleCommitMode
+					});
+					if (renderOutcome === "hard-navigate") {
+						startedHardNavigation = true;
+						browserNavigationController.abandonPendingBrowserRouterState(pendingRouterState);
+					}
+					if (renderOutcome !== "committed") return;
 					if (hasSupplementalRefresh) {
 						clearVisitedResponseCache();
 						return;
@@ -1501,9 +1603,13 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 				navigationAbortHandle.release();
 				browserNavigationController.finalizeNavigation(navId, pendingRouterState);
 				discardedServerActionRefreshScheduler.markNavigationSettled();
+				if (startedHardNavigation) await waitForMpaNavigationRestore();
 			}
 		},
-		preparePrefetchResponse: (response) => decodeAppElementsPromise(createFromFetch(Promise.resolve(response))),
+		preparePrefetchResponse: (response) => {
+			if (!isRscResponseCompatible(response.headers.get("X-Vinext-RSC-Compatibility-Id"))) return Promise.reject(/* @__PURE__ */ new Error("[vinext] Prefetched another deployment's payload"));
+			return decodeAppElementsPromise(createFromFetch(Promise.resolve(response)));
+		},
 		claimCurrentHistoryTreeSnapshot: (historyUpdateMode, previousHistoryState) => historyController.claimCurrentHistoryTreeSnapshot(historyUpdateMode, previousHistoryState),
 		commitAppOwnedHistoryStateWrite: (historyUpdateMode, previousHistoryState) => historyController.commitAppOwnedHistoryStateWrite(historyUpdateMode, previousHistoryState),
 		discardPendingNavigation: () => {
@@ -1609,7 +1715,12 @@ if (typeof document !== "undefined") {
 	});
 	window.addEventListener("pageshow", (event) => {
 		isPageUnloading = false;
-		if (event.persisted) mpaNavigationScheduler.reset();
+		if (event.persisted) {
+			mpaNavigationScheduler.reset();
+			mpaNavigationTree?.restore();
+			mpaNavigationRestore?.resolve();
+			mpaNavigationRestore = null;
+		}
 	});
 	main();
 }

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

@@ -4,8 +4,11 @@ type VinextHydrateRootErrorInfo = {
   errorBoundary?: unknown;
 };
 type HydrateRootErrorHandler = (error: unknown, errorInfo: VinextHydrateRootErrorInfo) => void;
-export declare function createOnUncaughtError(): HydrateRootErrorHandler;
+export declare function createOnUncaughtError(options?: {
+  coerceToError?: boolean;
+}): HydrateRootErrorHandler;
 export declare function createProdOnCaughtError(onImplicitRootError: HydrateRootErrorHandler): HydrateRootErrorHandler;
 export declare function createDevOnCaughtError(onCaughtError: HydrateRootErrorHandler, onImplicitRootError: HydrateRootErrorHandler): HydrateRootErrorHandler;
 export declare function createProdOnRecoverableError(onReportedError: () => void): (error: unknown) => void;
-//#endregion
+//#endregion
+export {};

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

@@ -18,9 +18,14 @@ function reportGlobalError(error) {
 	}
 	console.error(error);
 }
-function createOnUncaughtError() {
+function coerceError(value) {
+	if (isNavigationSignalError(value)) return value;
+	if (typeof value === "object" && value !== null && "name" in value && "message" in value) return value;
+	return new Error(String(value));
+}
+function createOnUncaughtError(options = {}) {
 	return (error) => {
-		reportGlobalError(error);
+		reportGlobalError(options.coerceToError ? coerceError(error) : error);
 	};
 }
 function createProdOnCaughtError(onImplicitRootError) {

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

@@ -121,4 +121,5 @@ export declare class AppBrowserHistoryController {
    */
   restoreHistorySnapshot(options: RestoreHistorySnapshotOptions): boolean;
 }
-//#endregion
+//#endregion
+export {};

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

@@ -38,4 +38,5 @@ export declare function resolveFetchedHydrationLocation(renderedPathAndSearch: s
   pathname: string;
   search: string;
 };
-//#endregion
+//#endregion
+export {};

package/dist/server/app-browser-interception-context.d.ts

@@ -1,10 +1,10 @@
-import { RouteManifest } from "../routing/app-route-graph.js";
+import { BrowserRouteManifest } from "../routing/browser-route-manifest.js";
 //#region src/server/app-browser-interception-context.d.ts
 type ResolveManifestNavigationInterceptionContextOptions = {
   basePath: string;
   currentMatchedPathname?: string | null;
   currentPathname: string;
-  routeManifest: RouteManifest | null;
+  routeManifest: BrowserRouteManifest | null;
   targetPathname: string;
 };
 /**
@@ -20,4 +20,5 @@ type ResolveManifestNavigationInterceptionContextOptions = {
  */
 export declare function resolveManifestNavigationInterceptionContext(options: ResolveManifestNavigationInterceptionContextOptions): string | null;
 export declare function resolveMiddlewareRewriteNavigationInterceptionContext(options: ResolveManifestNavigationInterceptionContextOptions): string | null;
-//#endregion
+//#endregion
+export {};

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

@@ -1,6 +1,7 @@
 import { HistoryUpdateMode } from "./app-browser-navigation-controller.js";
 //#region src/server/app-browser-mpa-navigation.d.ts
 export type AppBrowserMpaNavigationWindow = {
+  document?: Pick<Document, "visibilityState">;
   location: Pick<Location, "assign" | "replace">;
   requestAnimationFrame?: (callback: FrameRequestCallback) => unknown;
   setTimeout(callback: () => void, timeout: number): unknown;

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

@@ -14,21 +14,22 @@ var AppBrowserMpaNavigationScheduler = class {
 		this.#pendingNavigation = null;
 	}
 	navigate(targetWindow, href, historyUpdateMode) {
-		const pendingNavigation = this.#pendingNavigation;
-		if (pendingNavigation?.href === href && pendingNavigation.historyUpdateMode === historyUpdateMode) return;
+		if (this.#pendingNavigation?.href === href) return;
 		const token = this.#nextToken + 1;
 		this.#nextToken = token;
 		this.#pendingNavigation = {
 			href,
-			historyUpdateMode,
 			token
 		};
 		const navigate = () => {
-			const currentNavigation = this.#pendingNavigation;
-			if (currentNavigation?.href !== href || currentNavigation.historyUpdateMode !== historyUpdateMode || currentNavigation.token !== token) return;
+			if (this.#pendingNavigation?.token !== token) return;
 			if (historyUpdateMode === "replace") targetWindow.location.replace(href);
 			else targetWindow.location.assign(href);
 		};
+		if (targetWindow.document?.visibilityState === "hidden") {
+			navigate();
+			return;
+		}
 		if (typeof targetWindow.requestAnimationFrame === "function") {
 			targetWindow.requestAnimationFrame(() => {
 				targetWindow.setTimeout(navigate, 0);