vinext 0.1.2 → 0.1.3

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

@@ -4,40 +4,43 @@ 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 { installWindowNext, setWindowNextInternalSourcePage } from "../client/window-next.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 { clearAppNavigationFailureTarget, installAppNavigationFailureListeners } from "../client/app-nav-failure-handler.js";
 import { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext } from "./app-browser-interception-context.js";
 import { readHistoryStatePreviousNextUrl } from "./app-history-state.js";
-import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, resolveRscCompatibilityNavigationDecision } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
 import { AppBrowserMpaNavigationScheduler } from "./app-browser-mpa-navigation.js";
 import { navigationPlanner } from "./navigation-planner.js";
 import { beginAppRouterScrollIntent, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
-import { __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, 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 { __basePath, appRouterInstance, commitClientNavigationState, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, decodeRedirectError, getBfcacheIdMapContext, getClientNavigationRenderContext, getPrefetchCache, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, isRedirectError, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname, useRouter } from "../shims/navigation.js";
+import DefaultGlobalError from "../shims/default-global-error.js";
+import { DevRecoveryBoundary, GlobalErrorBoundary, RedirectBoundary } from "../shims/error-boundary.js";
 import { AppRouterScrollCommitProvider } from "../shims/app-router-scroll.js";
 import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
 import "../client/instrumentation-client.js";
-import { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, resolveServerActionRedirectCompatibilityHardNavigationTarget, shouldCheckRscCompatibilityForServerActionResponse, shouldClearClientNavigationCachesForServerActionResult } from "./app-browser-action-result.js";
+import { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, 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, createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, isCacheRestorableAppPayloadMetadata, resolveInterceptionContextFromPreviousNextUrl, resolveServerActionRequestState } from "./app-browser-state.js";
 import { clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch } from "./app-browser-navigation-controller.js";
+import { applyServerActionResultDecision } from "./app-browser-server-action-navigation.js";
 import { consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition } from "./app-browser-hydration.js";
 import { AppBrowserHistoryController } from "./app-browser-history-controller.js";
 import { createVisitedResponseCacheEntry, isVisitedResponseCacheEntryFresh } from "./app-visited-response-cache.js";
 import { createPopstateRestoreHandler, restoreSynchronousPopstateScrollPosition } from "./app-browser-popstate.js";
-import { createOnUncaughtError, prodOnCaughtError } from "./app-browser-error.js";
+import { createDevOnCaughtError, createOnUncaughtError, createProdOnCaughtError, prodOnRecoverableError } from "./app-browser-error.js";
 import { dismissOverlay } from "./dev-error-overlay-store.js";
-import { devOnCaughtError, devOnUncaughtError, installDevErrorOverlay, installViteHmrErrorHandler, reportInitialDevServerErrors } from "./dev-error-overlay.js";
+import { devOnCaughtError, installDevErrorOverlay, installViteHmrErrorHandler, reportInitialDevServerErrors } from "./dev-error-overlay.js";
 import { throwOnServerActionNotFound } from "./server-action-not-found.js";
 import { createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, 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";
 import { createFromFetch, createFromReadableStream, createTemporaryReferenceSet, encodeReply, setServerCallback } from "@vitejs/plugin-rsc/browser";
-import { hydrateRoot } from "react-dom/client";
+import { createRoot, hydrateRoot } from "react-dom/client";
 //#region src/server/app-browser-entry.ts
 function toActionType(kind) {
 	return kind === "traverse" ? "traverse" : "navigate";
@@ -55,6 +58,14 @@ const CLIENT_RSC_COMPATIBILITY_ID = getVinextRscCompatibilityId();
 const optimisticRouteTemplates = /* @__PURE__ */ new Map();
 const optimisticRouteTemplateSources = /* @__PURE__ */ new Set();
 const optimisticRouteTemplateLearning = /* @__PURE__ */ new Map();
+function claimInitialAppRouterBootstrap() {
+	if (window.__VINEXT_RSC_ROOT__ || window.__VINEXT_RSC_BOOTSTRAP_STATE__) return false;
+	window.__VINEXT_RSC_BOOTSTRAP_STATE__ = "starting";
+	return true;
+}
+function markInitialAppRouterBootstrapHydrated() {
+	window.__VINEXT_RSC_BOOTSTRAP_STATE__ = "hydrated";
+}
 function getBrowserRouteManifest() {
 	return getNavigationRuntime()?.bootstrap.routeManifest ?? null;
 }
@@ -109,10 +120,10 @@ function isRouterStatePromise(value) {
 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;
+const DEFAULT_GLOBAL_ERROR_COMPONENT = DefaultGlobalError;
 let latestRscHmrUpdateId = 0;
 let synchronousPopstateScrollRestoreNavigationId = null;
 function waitForRscHmrSettle(delayMs = RSC_HMR_SETTLE_DELAY_MS) {
@@ -262,39 +273,31 @@ function createNavigationCommitEffect(options) {
 			stageClientParams: () => stageClientParams(params),
 			targetHistoryIndex
 		});
-		pendingNavigationRecoveryHref = null;
+		clearAppNavigationFailureTarget(href);
 		commitClientNavigationState(navId);
 	};
 }
 async function renderNavigationPayload(payload, navigationSnapshot, targetHref, navId, historyUpdateMode, params, previousNextUrl, pendingRouterState, payloadOrigin, actionType = "navigate", operationLane = "navigation", traversalIntent = null, scrollIntent = null, restoredBfcacheIds = null, reuseCurrentBfcacheIds = true, visibleCommitMode = "transition") {
 	syncServerActionHttpFallbackHead(null);
-	try {
-		return await browserNavigationController.renderNavigationPayload({
-			actionType,
-			createNavigationCommitEffect: (options) => {
-				pendingNavigationRecoveryHref = options.href;
-				return createNavigationCommitEffect(options);
-			},
-			historyUpdateMode,
-			navigationSnapshot,
-			nextElements: payload,
-			operationLane,
-			payloadOrigin,
-			params,
-			pendingRouterState,
-			previousNextUrl,
-			scrollIntent,
-			restoredBfcacheIds,
-			reuseCurrentBfcacheIds,
-			targetHistoryIndex: traversalIntent === null ? void 0 : traversalIntent.targetHistoryIndex,
-			targetHref,
-			navId,
-			visibleCommitMode
-		});
-	} catch (error) {
-		pendingNavigationRecoveryHref = null;
-		throw error;
-	}
+	return browserNavigationController.renderNavigationPayload({
+		actionType,
+		createNavigationCommitEffect,
+		historyUpdateMode,
+		navigationSnapshot,
+		nextElements: payload,
+		operationLane,
+		payloadOrigin,
+		params,
+		pendingRouterState,
+		previousNextUrl,
+		scrollIntent,
+		restoredBfcacheIds,
+		reuseCurrentBfcacheIds,
+		targetHistoryIndex: traversalIntent === null ? void 0 : traversalIntent.targetHistoryIndex,
+		targetHref,
+		navId,
+		visibleCommitMode
+	});
 }
 function resolveActionRedirectTarget(response) {
 	const actionRedirect = response.headers.get(ACTION_REDIRECT_HEADER);
@@ -360,23 +363,39 @@ function evictVisitedResponseCacheIfNeeded() {
 		visitedResponseCache.delete(oldest);
 	}
 }
-function getVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, navigationKind) {
+function readVisitedResponseCacheCandidate(rscUrl, interceptionContext, mountedSlotsHeader, navigationKind) {
 	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 	const cached = visitedResponseCache.get(cacheKey);
-	if (!cached) return null;
-	if ((cached.response.mountedSlotsHeader ?? null) !== mountedSlotsHeader) {
-		visitedResponseCache.delete(cacheKey);
-		return null;
-	}
-	if (isVisitedResponseCacheEntryFresh(cached, {
-		navigationKind,
-		now: Date.now()
-	})) {
-		visitedResponseCache.delete(cacheKey);
-		visitedResponseCache.set(cacheKey, cached);
-		return cached;
+	if (!cached) return {
+		cacheKey,
+		entry: null,
+		facts: {
+			candidate: "missing",
+			navigationKind
+		}
+	};
+	return {
+		cacheKey,
+		entry: cached,
+		facts: {
+			candidate: "present",
+			fresh: isVisitedResponseCacheEntryFresh(cached, {
+				navigationKind,
+				now: Date.now()
+			}),
+			mountedSlotsMatch: (cached.response.mountedSlotsHeader ?? null) === mountedSlotsHeader,
+			navigationKind
+		}
+	};
+}
+function applyVisitedResponseCacheCandidateDecision(candidate, decision) {
+	if (candidate.entry === null) return null;
+	if (decision.kind === "reuse") {
+		visitedResponseCache.delete(candidate.cacheKey);
+		visitedResponseCache.set(candidate.cacheKey, candidate.entry);
+		return candidate.entry;
 	}
-	visitedResponseCache.delete(cacheKey);
+	visitedResponseCache.delete(candidate.cacheKey);
 	return null;
 }
 function deleteVisitedResponse(rscUrl, interceptionContext) {
@@ -525,20 +544,25 @@ function BrowserRoot({ initialElements, initialNavigationSnapshot }) {
 			return new Promise(() => {});
 		} });
 		browserRouterStateHasEverCommitted = true;
-		const hydratedAt = performance.now();
-		window.__VINEXT_HYDRATED_AT = hydratedAt;
-		window.__NEXT_HYDRATED = true;
-		window.__NEXT_HYDRATED_AT = hydratedAt;
-		window.__NEXT_HYDRATED_CB?.();
 		return () => {
 			registerNavigationRuntimeFunctions({ navigateExternal: void 0 });
 			detach();
 			setMountedSlotsHeader(null);
 		};
 	}, [setTreeStateValue]);
+	useEffect(() => {
+		const hydratedAt = performance.now();
+		window.__VINEXT_HYDRATED_AT = hydratedAt;
+		window.__NEXT_HYDRATED = true;
+		window.__NEXT_HYDRATED_AT = hydratedAt;
+		window.__NEXT_HYDRATED_CB?.();
+	}, []);
 	useLayoutEffect(() => {
 		historyController.rememberHistoryStateSnapshot(treeState);
 	}, [treeState]);
+	useEffect(() => {
+		setWindowNextInternalSourcePage(AppElementsWire.readMetadata(treeState.elements).sourcePage);
+	}, [treeState.elements]);
 	useLayoutEffect(() => {
 		setMountedSlotsHeader(getMountedSlotIdsHeader(stateRef.current.elements));
 		removeStylesheetLinksCoveredByInlineCss();
@@ -564,13 +588,17 @@ function BrowserRoot({ initialElements, initialNavigationSnapshot }) {
 	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, {
+		isImplicitRootErrorBoundary: true,
 		resetKey: treeState.renderId,
 		onCatch: handleDevRecoveryBoundaryCatch
 	}, innerTree) : innerTree;
-	const scrollScopedTree = createElement(AppRouterScrollCommitProvider, { commitId: treeState.renderId }, committedTree);
+	const rootErrorTree = createElement(GlobalErrorBoundary, {
+		fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,
+		children: createElement(AppRouterScrollCommitProvider, { commitId: treeState.renderId }, committedTree)
+	});
 	const ClientNavigationRenderContext = getClientNavigationRenderContext();
-	if (!ClientNavigationRenderContext) return scrollScopedTree;
-	return createElement(ClientNavigationRenderContext.Provider, { value: treeState.navigationSnapshot }, scrollScopedTree);
+	if (!ClientNavigationRenderContext) return rootErrorTree;
+	return createElement(ClientNavigationRenderContext.Provider, { value: treeState.navigationSnapshot }, rootErrorTree);
 }
 function restoreHydrationNavigationContext(pathname, searchParams, params) {
 	setNavigationContext({
@@ -698,31 +726,23 @@ function registerServerActionCallback() {
 		const hasActionRedirect = fetchResponse.headers.has(ACTION_REDIRECT_HEADER);
 		const actionRedirectTarget = resolveActionRedirectTarget(fetchResponse);
 		if (hasActionRedirect && !actionRedirectTarget) return;
-		const actionRedirectCompatibilityHardNavigationTarget = resolveServerActionRedirectCompatibilityHardNavigationTarget({
+		const actionResultFacts = createServerActionResultFacts({
 			actionRedirectHref: actionRedirectTarget?.href ?? null,
+			actionRedirectType: actionRedirectTarget?.type ?? null,
 			clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
-			response: fetchResponse
-		});
-		if (actionRedirectCompatibilityHardNavigationTarget) {
-			clearClientNavigationCaches();
-			browserNavigationController.performHardNavigation(actionRedirectCompatibilityHardNavigationTarget, actionRedirectTarget?.type === "push" ? "assign" : "replace");
-			return;
-		}
-		if (!actionRedirectTarget && shouldCheckRscCompatibilityForServerActionResponse(fetchResponse) && resolveRscCompatibilityNavigationDecision({
-			clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
+			compatibilityIdHeader: fetchResponse.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER),
+			contentTypeHeader: fetchResponse.headers.get("content-type"),
 			currentHref: actionInitiation.href,
 			origin: window.location.origin,
-			responseCompatibilityId: fetchResponse.headers.get("X-Vinext-RSC-Compatibility-Id"),
 			responseUrl: fetchResponse.url
-		}).kind === "hard-navigate") {
-			browserNavigationController.performHardNavigation(actionInitiation.href);
-			return;
-		}
+		});
+		const fetchResponseIsRsc = actionResultFacts.isRscContentType;
+		if (applyServerActionResultDecision(navigationPlanner.classifyServerActionResult(actionResultFacts), clearClientNavigationCaches, (url, historyMode) => browserNavigationController.performHardNavigation(url, historyMode))) return;
 		const revalidation = parseServerActionRevalidationHeader(fetchResponse.headers);
 		if (revalidation !== "none") clearClientNavigationCaches();
 		const invalidResponseError = await readInvalidServerActionResponseError(fetchResponse.clone(), actionRedirectTarget !== null);
 		if (invalidResponseError) throw invalidResponseError;
-		if (actionRedirectTarget && !shouldCheckRscCompatibilityForServerActionResponse(fetchResponse)) {
+		if (actionRedirectTarget && !fetchResponseIsRsc) {
 			browserNavigationController.performHardNavigation(actionRedirectTarget.href);
 			return;
 		}
@@ -770,7 +790,9 @@ function registerServerActionCallback() {
 	});
 }
 async function main() {
+	if (!claimInitialAppRouterBootstrap()) return;
 	registerServerActionCallback();
+	installAppNavigationFailureListeners();
 	if (import.meta.env.DEV) {
 		installDevErrorOverlay();
 		installViteHmrErrorHandler(import.meta.hot);
@@ -784,27 +806,39 @@ function bootstrapHydration(rscStream) {
 	const root = decodeAppElementsPromise(createFromReadableStream(rscStream));
 	const initialNavigationSnapshot = createClientNavigationRenderSnapshot(window.location.href, latestClientParams);
 	historyController.writeBootstrapHistoryMetadata();
-	const onUncaughtError = import.meta.env.DEV ? devOnUncaughtError : createOnUncaughtError(() => pendingNavigationRecoveryHref);
+	const onUncaughtError = createOnUncaughtError();
 	const formState = consumeInitialFormState(getVinextBrowserGlobal());
 	const hydrateRootOptions = import.meta.env.DEV ? createVinextHydrateRootOptions({
 		formState,
-		onCaughtError: devOnCaughtError,
+		onCaughtError: createDevOnCaughtError(devOnCaughtError, onUncaughtError),
 		onUncaughtError
 	}) : createVinextHydrateRootOptions({
 		formState,
-		onCaughtError: prodOnCaughtError,
+		onCaughtError: createProdOnCaughtError(onUncaughtError),
+		onRecoverableError: prodOnRecoverableError,
 		onUncaughtError
 	});
-	window.__VINEXT_RSC_ROOT__ = hydrateRootInTransition({
-		children: createElement(BrowserRoot, {
-			initialElements: root,
-			initialNavigationSnapshot
-		}),
+	const children = createElement(BrowserRoot, {
+		initialElements: root,
+		initialNavigationSnapshot
+	});
+	const errorShellStyles = document.querySelectorAll("style[data-vinext-error-shell-style]");
+	if (document.documentElement.id === "__next_error__") {
+		const { formState: _inertFormState, ...createRootOptions } = hydrateRootOptions;
+		for (const style of errorShellStyles) style.remove();
+		startTransition(() => {
+			const clientRoot = createRoot(document, createRootOptions);
+			clientRoot.render(children);
+			window.__VINEXT_RSC_ROOT__ = clientRoot;
+		});
+	} else window.__VINEXT_RSC_ROOT__ = hydrateRootInTransition({
+		children,
 		container: document,
 		hydrateRoot,
 		options: hydrateRootOptions,
 		startTransition
 	});
+	markInitialAppRouterBootstrapHydrated();
 	registerNavigationRuntimeFunctions({
 		clearNavigationCaches: clearClientNavigationCaches,
 		commitHashNavigation: (href, historyUpdateMode, scroll) => historyController.commitHashOnlyNavigation(href, historyUpdateMode, scroll),
@@ -820,7 +854,9 @@ function bootstrapHydration(rscStream) {
 			const activeTraversalIntent = navigationKind === "traverse" ? traversalIntent ?? historyController.resolveTraversalIntent(window.history.state) : null;
 			const performHardNavigationForScrollIntent = (targetHref) => {
 				consumeAppRouterScrollIntent(scrollIntent ?? null);
-				return browserNavigationController.performHardNavigation(targetHref);
+				const didNavigate = browserNavigationController.performHardNavigation(targetHref);
+				if (!didNavigate) clearAppNavigationFailureTarget(targetHref);
+				return didNavigate;
 			};
 			let restoredBfcacheIds = navigationKind === "traverse" ? historyController.readCurrentBfcacheVersionHistoryIds(activeTraversalIntent?.historyState ?? window.history.state) : null;
 			const reuseCurrentBfcacheIds = navigationKind !== "traverse" || !historyController.isCacheInvalidationGuarded() && historyController.isCurrentBfcacheVersion(activeTraversalIntent?.historyState ?? window.history.state);
@@ -856,8 +892,35 @@ function bootstrapHydration(rscStream) {
 						renderMode: navigationKind === "refresh" ? APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI : void 0
 					});
 					const rscUrl = await createRscRequestUrl(url.pathname + url.search, requestHeaders);
-					const cachedRoute = shouldBypassNavigationCache ? null : getVisitedResponse(rscUrl, requestInterceptionContext, mountedSlotsHeader, navigationKind);
-					if (cachedRoute) {
+					const visitedResponseCandidate = shouldBypassNavigationCache ? {
+						cacheKey: AppElementsWire.encodeCacheKey(rscUrl, requestInterceptionContext),
+						entry: null,
+						facts: {
+							candidate: "missing",
+							navigationKind
+						}
+					} : readVisitedResponseCacheCandidate(rscUrl, requestInterceptionContext, mountedSlotsHeader, navigationKind);
+					const cachedRoute = applyVisitedResponseCacheCandidateDecision(visitedResponseCandidate, navigationPlanner.classifyVisitedResponseCacheCandidate(visitedResponseCandidate.facts));
+					const visitedResponse = cachedRoute === null ? { status: "unavailable" } : { status: "available" };
+					const prefetchProbeDecision = navigationPlanner.classifyNavigationPrefetchProbe({
+						bypassNavigationCache: shouldBypassNavigationCache,
+						navigationKind,
+						visitedResponse
+					});
+					let routeManifest = navigationKind === "navigate" ? getBrowserRouteManifest() : null;
+					const hasPrefetchCandidate = prefetchProbeDecision.kind === "probe" && hasPrefetchCacheEntryForNavigation(rscUrl, requestInterceptionContext, mountedSlotsHeader, { notifyInvalidation: false });
+					const reuseDecision = navigationPlanner.classifyNavigationReuse({
+						bypassNavigationCache: shouldBypassNavigationCache,
+						navigationKind,
+						optimisticRouteShell: routeManifest === null ? {
+							reason: "routeManifestMissing",
+							status: "unavailable"
+						} : { status: "available" },
+						prefetch: hasPrefetchCandidate ? { status: "available" } : { status: "unavailable" },
+						targetHref: currentHref,
+						visitedResponse
+					});
+					if (reuseDecision.kind === "reuseVisitedResponse" && cachedRoute) {
 						const cachedFetchDecision = navigationPlanner.classifyRscFetchResult({
 							clientCompatibilityId: CLIENT_RSC_COMPATIBILITY_ID,
 							compatibilityIdHeader: cachedRoute.response.compatibilityIdHeader ?? null,
@@ -900,7 +963,8 @@ function bootstrapHydration(rscStream) {
 					let navResponse;
 					let navResponseExpiresAt;
 					let navResponseUrl = null;
-					if (navigationKind !== "refresh" && !shouldBypassNavigationCache) {
+					let fallbackReuseDecision = reuseDecision;
+					if (reuseDecision.kind === "consumePrefetch") {
 						const prefetchedResponse = await consumePrefetchResponseForNavigation(rscUrl, requestInterceptionContext, mountedSlotsHeader, { shouldConsume: () => browserNavigationController.isCurrentNavigation(navId) });
 						if (!browserNavigationController.isCurrentNavigation(navId)) return;
 						if (prefetchedResponse) {
@@ -908,9 +972,22 @@ function bootstrapHydration(rscStream) {
 							navResponseExpiresAt = prefetchedResponse.expiresAt;
 							navResponseUrl = prefetchedResponse.url;
 						}
+						if (!navResponse) {
+							routeManifest = navigationKind === "navigate" ? getBrowserRouteManifest() : null;
+							fallbackReuseDecision = navigationPlanner.classifyNavigationReuse({
+								bypassNavigationCache: shouldBypassNavigationCache,
+								navigationKind,
+								optimisticRouteShell: routeManifest === null ? {
+									reason: "routeManifestMissing",
+									status: "unavailable"
+								} : { status: "available" },
+								prefetch: { status: "unavailable" },
+								targetHref: currentHref,
+								visitedResponse: { status: "unavailable" }
+							});
+						}
 					}
-					if (!navResponse && navigationKind === "navigate") {
-						const routeManifest = getBrowserRouteManifest();
+					if (!navResponse && fallbackReuseDecision.kind === "attemptOptimisticRouteShell") {
 						await learnOptimisticRouteTemplatesFromPrefetchCache({
 							interceptionContext: requestInterceptionContext,
 							mountedSlotsHeader,
@@ -1012,7 +1089,7 @@ function bootstrapHydration(rscStream) {
 			} catch (error) {
 				if (!browserNavigationController.isCurrentNavigation(navId)) return;
 				if (!isPageUnloading) console.error("[vinext] RSC navigation error:", error);
-				performHardNavigationForScrollIntent(currentHref);
+				performHardNavigationForScrollIntent(navigationPlanner.classifyRscNavigationError({ currentHref }).url);
 			} finally {
 				browserNavigationController.finalizeNavigation(navId, pendingRouterState);
 				discardedServerActionRefreshScheduler.markNavigationSettled();

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

@@ -1,9 +1,13 @@
 //#region src/server/app-browser-error.d.ts
-declare function createOnUncaughtError(getRecoveryHref: () => string | null): (error: unknown, errorInfo: {
+type VinextHydrateRootErrorInfo = {
   componentStack?: string;
-}) => void;
-declare function prodOnCaughtError(error: unknown, errorInfo: {
-  componentStack?: string;
-}): void;
+  errorBoundary?: unknown;
+};
+type HydrateRootErrorHandler = (error: unknown, errorInfo: VinextHydrateRootErrorInfo) => void;
+declare function createOnUncaughtError(): HydrateRootErrorHandler;
+declare function createProdOnCaughtError(onImplicitRootError: HydrateRootErrorHandler): HydrateRootErrorHandler;
+declare function createDevOnCaughtError(onCaughtError: HydrateRootErrorHandler, onImplicitRootError: HydrateRootErrorHandler): HydrateRootErrorHandler;
+declare function prodOnCaughtError(error: unknown, errorInfo: VinextHydrateRootErrorInfo): void;
+declare function prodOnRecoverableError(error: unknown): void;
 //#endregion
-export { createOnUncaughtError, prodOnCaughtError };
+export { createDevOnCaughtError, createOnUncaughtError, createProdOnCaughtError, prodOnCaughtError, prodOnRecoverableError };

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

@@ -1,17 +1,52 @@
+import { isUnknownRecord } from "../utils/record.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
 //#region src/server/app-browser-error.ts
-function createOnUncaughtError(getRecoveryHref) {
+function isImplicitRootErrorBoundary(errorInfo) {
+	if (!isUnknownRecord(errorInfo.errorBoundary)) return false;
+	const props = errorInfo.errorBoundary.props;
+	return isUnknownRecord(props) && props.isImplicitRootErrorBoundary === true;
+}
+function logCaughtError(error, errorInfo) {
+	console.error(error);
+	if (errorInfo?.componentStack) console.error("The above error occurred in a React component:\n" + errorInfo.componentStack);
+}
+function reportGlobalError(error) {
+	if (typeof globalThis.reportError === "function") {
+		globalThis.reportError(error);
+		return;
+	}
+	console.error(error);
+}
+function createOnUncaughtError() {
+	return (error) => {
+		reportGlobalError(error);
+	};
+}
+function createProdOnCaughtError(onImplicitRootError) {
+	return (error, errorInfo) => {
+		if (isNavigationSignalError(error)) return;
+		if (isImplicitRootErrorBoundary(errorInfo)) {
+			onImplicitRootError(error, errorInfo);
+			return;
+		}
+		logCaughtError(error, errorInfo);
+	};
+}
+function createDevOnCaughtError(onCaughtError, onImplicitRootError) {
 	return (error, errorInfo) => {
-		console.error(error);
-		if (errorInfo?.componentStack) console.error("The above error occurred in a React component:\n" + errorInfo.componentStack);
-		const recoveryHref = getRecoveryHref();
-		if (recoveryHref !== null) window.location.assign(recoveryHref);
+		if (isImplicitRootErrorBoundary(errorInfo)) {
+			onImplicitRootError(error, errorInfo);
+			return;
+		}
+		onCaughtError(error, errorInfo);
 	};
 }
 function prodOnCaughtError(error, errorInfo) {
 	if (isNavigationSignalError(error)) return;
-	console.error(error);
-	if (errorInfo?.componentStack) console.error("The above error occurred in a React component:\n" + errorInfo.componentStack);
+	logCaughtError(error, errorInfo);
+}
+function prodOnRecoverableError(error) {
+	reportGlobalError(error instanceof Error && error.cause !== void 0 ? error.cause : error);
 }
 //#endregion
-export { createOnUncaughtError, prodOnCaughtError };
+export { createDevOnCaughtError, createOnUncaughtError, createProdOnCaughtError, prodOnCaughtError, prodOnRecoverableError };

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

@@ -8,6 +8,7 @@ type HydrateRootChildren = Parameters<HydrateRoot>[1];
 type HydrateRootReturn = ReturnType<HydrateRoot>;
 type HydrateRootCaughtErrorHandler = NonNullable<HydrateRootOptions["onCaughtError"]>;
 type HydrateRootUncaughtErrorHandler = NonNullable<HydrateRootOptions["onUncaughtError"]>;
+type HydrateRootRecoverableErrorHandler = NonNullable<HydrateRootOptions["onRecoverableError"]>;
 type StartTransition = (action: () => void) => void;
 declare const RSC_FORM_STATE_GLOBAL = "__VINEXT_RSC_FORM_STATE__";
 type FormStateGlobal = {
@@ -17,6 +18,7 @@ declare function consumeInitialFormState(global: FormStateGlobal): ReactFormStat
 declare function createVinextHydrateRootOptions(options: {
   formState: ReactFormState | null;
   onCaughtError?: HydrateRootCaughtErrorHandler;
+  onRecoverableError?: HydrateRootRecoverableErrorHandler;
   onUncaughtError: HydrateRootUncaughtErrorHandler;
 }): HydrateRootOptions;
 declare function hydrateRootInTransition(options: {

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

@@ -8,6 +8,7 @@ function consumeInitialFormState(global) {
 function createVinextHydrateRootOptions(options) {
 	const hydrateOptions = {
 		formState: options.formState,
+		...options.onRecoverableError ? { onRecoverableError: options.onRecoverableError } : {},
 		onUncaughtError: options.onUncaughtError
 	};
 	if (options.onCaughtError) return {

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

@@ -1,9 +1,9 @@
 import { RouteManifest } from "../routing/app-route-graph.js";
 import { AppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { NavigationRuntimeVisibleCommitMode } from "../client/navigation-runtime.js";
-import { ServerActionRevalidationKind } from "./app-browser-action-result.js";
 import { AppElements } from "./app-elements-wire.js";
 import { OperationLane } from "./navigation-planner.js";
+import { ServerActionRevalidationKind } from "./app-browser-action-result.js";
 import { ClientNavigationRenderSnapshot, commitClientNavigationState, createSnapshotPathAndSearch } from "../shims/navigation.js";
 import { AppNavigationPayloadOrigin, AppRouterState } from "./app-browser-state.js";
 import { Dispatch, ReactNode } from "react";
@@ -17,6 +17,7 @@ type PendingBrowserRouterState = {
 };
 type NavigationPayloadOutcome = "committed" | "no-commit" | "hard-navigate";
 type HardNavigationMode = "assign" | "replace";
+type BrowserNavigationCommitEffect = () => void;
 type BrowserNavigationCommitEffectFactory = (options: {
   bfcacheIds: Readonly<Record<string, string>>;
   href: string;
@@ -25,7 +26,7 @@ type BrowserNavigationCommitEffectFactory = (options: {
   params: Record<string, string | string[]>;
   previousNextUrl: string | null;
   targetHistoryIndex?: number | null;
-}) => () => void;
+}) => BrowserNavigationCommitEffect;
 type BrowserRouterStateRef = {
   current: AppRouterState;
 };
@@ -92,6 +93,7 @@ type BrowserNavigationController = {
    * navigation would otherwise be lost.
    */
   drainPrePaintEffects(renderId: number): void;
+  clearCommittedNavigationFailureTargets(renderId: number): void;
   NavigationCommitSignal(this: void, {
     renderId,
     children