vinext 0.1.0 → 0.1.1

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

@@ -9,8 +9,8 @@ import { installWindowNext } 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 { resolveManifestNavigationInterceptionContext } from "./app-browser-interception-context.js";
-import { createHistoryStateWithNavigationMetadata, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
+import { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext } from "./app-browser-interception-context.js";
+import { RestorableClientStateController, createHistoryStateWithNavigationMetadata, readHistoryStateBfcacheIds, 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";
@@ -23,10 +23,10 @@ import { createDiscardedServerActionRefreshScheduler, createServerActionInitiati
 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 } from "./app-browser-navigation-controller.js";
+import { clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch, createSnapshotPathAndSearch } 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 { createPopstateRestoreHandler, restoreSynchronousPopstateScrollPosition } from "./app-browser-popstate.js";
 import { createOnUncaughtError } from "./app-browser-error.js";
 import { dismissOverlay } from "./dev-error-overlay-store.js";
 import { devOnCaughtError, devOnUncaughtError, installDevErrorOverlay, installViteHmrErrorHandler, reportInitialDevServerErrors } from "./dev-error-overlay.js";
@@ -35,6 +35,7 @@ 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, 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";
 //#region src/server/app-browser-entry.ts
@@ -58,6 +59,7 @@ function getBrowserRouteManifest() {
 	return getNavigationRuntime()?.bootstrap.routeManifest ?? null;
 }
 const browserNavigationController = createAppBrowserNavigationController({
+	basePath: __basePath,
 	getRouteManifest: getBrowserRouteManifest,
 	syncHistoryStatePreviousNextUrl: syncCurrentHistoryStatePreviousNextUrl
 });
@@ -96,26 +98,18 @@ 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);
-}
+let synchronousPopstateScrollRestoreNavigationId = null;
+const restorableClientState = new RestorableClientStateController({
+	initialHistoryState: window.history.state,
+	maxHistoryStateSnapshots: 50
+});
 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;
@@ -131,10 +125,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 bfcacheIds = hasBrowserRouterState() ? getBrowserRouterState().bfcacheIds : restorableClientState.readCurrentBfcacheVersionHistoryIds(window.history.state);
 	const historyState = createHistoryStateWithNavigationMetadata(createHashOnlyNavigationBaseHistoryState(historyUpdateMode, scroll), {
 		bfcacheIds,
-		bfcacheVersion: bfcacheIds === null ? void 0 : currentBfcacheVersion,
+		bfcacheVersion: bfcacheIds === null ? void 0 : restorableClientState.currentBfcacheVersion,
 		previousNextUrl,
 		traversalIndex: navigationHistoryIndex
 	});
@@ -158,6 +152,26 @@ function stripVinextScrollState(state) {
 function commitTraversalIndexFromHistoryState(historyState) {
 	commitHistoryTraversalIndex(readHistoryStateTraversalIndex(historyState));
 }
+function restoreHistoryStateSnapshot(historyState) {
+	const decision = restorableClientState.resolveHistoryStateSnapshotRestore(historyState);
+	if (decision.kind === "skip") return false;
+	const navId = browserNavigationController.getActiveNavigationId();
+	let restored = false;
+	flushSync(() => {
+		restored = browserNavigationController.restoreHistorySnapshotVisibleState({
+			beforeCommit: () => {
+				commitHistoryTraversalIndex(decision.targetHistoryIndex);
+				stageClientParams(decision.state.navigationSnapshot.params);
+			},
+			navId,
+			state: decision.state,
+			targetHref: window.location.href
+		});
+	});
+	if (!restored) return false;
+	commitClientNavigationState();
+	return true;
+}
 function getBrowserRouterState() {
 	return browserNavigationController.getBrowserRouterState();
 }
@@ -190,7 +204,7 @@ function clearPrefetchState() {
 function clearClientNavigationCaches() {
 	clearVisitedResponseCache();
 	clearPrefetchState();
-	invalidateRestorableBfcacheIds();
+	restorableClientState.invalidateClientState();
 }
 function isSettledPrefetchCacheEntry(entry) {
 	return entry.outcome === "cache-seeded" && entry.pending === void 0 && entry.snapshot !== void 0;
@@ -267,18 +281,18 @@ function areBfcacheIdMapsEqual(a, b) {
 	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));
+	return readHistoryStatePreviousNextUrl(state) === previousNextUrl && (bfcacheIds === void 0 || areBfcacheIdMapsEqual(readHistoryStateBfcacheIds(state), bfcacheIds) && restorableClientState.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,
+		bfcacheVersion: bfcacheIds === void 0 ? void 0 : restorableClientState.currentBfcacheVersion,
 		previousNextUrl
 	});
 	replaceHistoryStateWithoutNotify(nextHistoryState, "", window.location.href);
 	if (isHistoryStateNavigationMetadataInSync(window.history.state, previousNextUrl, bfcacheIds)) return;
-	window.history.replaceState(nextHistoryState, "", window.location.href);
+	replaceHistoryStateWithoutNotify(nextHistoryState, "", window.location.href);
 }
 function createActionInitiationSnapshot() {
 	const routerState = getBrowserRouterState();
@@ -300,7 +314,7 @@ function createNavigationCommitEffect(options) {
 		const navigationHistoryIndex = targetHistoryIndex !== void 0 ? targetHistoryIndex : allocateNavigationHistoryTraversalIndex(historyUpdateMode);
 		const historyState = createHistoryStateWithNavigationMetadata(preserveExistingState ? window.history.state : null, {
 			bfcacheIds,
-			bfcacheVersion: currentBfcacheVersion,
+			bfcacheVersion: restorableClientState.currentBfcacheVersion,
 			previousNextUrl,
 			traversalIndex: navigationHistoryIndex
 		});
@@ -325,7 +339,7 @@ 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, restoredBfcacheIds = null) {
+async function renderNavigationPayload(payload, navigationSnapshot, targetHref, navId, historyUpdateMode, params, previousNextUrl, pendingRouterState, payloadOrigin, actionType = "navigate", operationLane = "navigation", traversalIntent = null, scrollIntent = null, restoredBfcacheIds = null, reuseCurrentBfcacheIds = true) {
 	syncServerActionHttpFallbackHead(null);
 	try {
 		return await browserNavigationController.renderNavigationPayload({
@@ -344,6 +358,7 @@ async function renderNavigationPayload(payload, navigationSnapshot, targetHref,
 			previousNextUrl,
 			scrollIntent,
 			restoredBfcacheIds,
+			reuseCurrentBfcacheIds,
 			targetHistoryIndex: traversalIntent === null ? void 0 : traversalIntent.targetHistoryIndex,
 			targetHref,
 			navId
@@ -476,6 +491,16 @@ function getRequestState(navigationKind, targetPathname, previousNextUrlOverride
 				interceptionContext: manifestInterceptionContext,
 				previousNextUrl: window.location.pathname + window.location.search
 			};
+			const middlewareRewriteInterceptionContext = resolveMiddlewareRewriteNavigationInterceptionContext({
+				basePath: __basePath,
+				currentPathname: window.location.pathname,
+				routeManifest: getBrowserRouteManifest(),
+				targetPathname
+			});
+			if (middlewareRewriteInterceptionContext !== null) return {
+				interceptionContext: middlewareRewriteInterceptionContext,
+				previousNextUrl: window.location.pathname + window.location.search
+			};
 			return {
 				interceptionContext: null,
 				previousNextUrl: null
@@ -584,6 +609,12 @@ function BrowserRoot({ initialElements, initialNavigationSnapshot }) {
 			setMountedSlotsHeader(null);
 		};
 	}, [setTreeStateValue]);
+	useLayoutEffect(() => {
+		restorableClientState.rememberHistoryStateSnapshot({
+			historyIndex: currentHistoryTraversalIndex,
+			state: treeState
+		});
+	}, [treeState]);
 	useLayoutEffect(() => {
 		setMountedSlotsHeader(getMountedSlotIdsHeader(stateRef.current.elements));
 		removeStylesheetLinksCoveredByInlineCss();
@@ -593,7 +624,7 @@ function BrowserRoot({ initialElements, initialNavigationSnapshot }) {
 		if (treeState.renderId !== 0) return;
 		replaceHistoryStateWithoutNotify(createHistoryStateWithNavigationMetadata(window.history.state, {
 			bfcacheIds: treeState.bfcacheIds,
-			bfcacheVersion: currentBfcacheVersion,
+			bfcacheVersion: restorableClientState.currentBfcacheVersion,
 			previousNextUrl: treeState.previousNextUrl,
 			traversalIndex: currentHistoryTraversalIndex
 		}), "", window.location.href);
@@ -634,16 +665,16 @@ function restorePopstateScrollPosition(state, options) {
 		return;
 	}
 	const y = Number(state.__vinext_scrollY);
-	retryScrollTo("__vinext_scrollX" in state ? Number(state.__vinext_scrollX) : 0, y, { shouldContinue });
+	retryScrollTo("__vinext_scrollX" in state ? Number(state.__vinext_scrollX) : 0, y, {
+		minFrames: 1,
+		shouldContinue
+	});
 }
 function isSameAppRoutePopstateTarget(href) {
 	if (!hasBrowserRouterState()) return false;
 	const target = new URL(href, window.location.origin);
 	const routerState = getBrowserRouterState();
-	const targetPathname = stripBasePath(target.pathname, __basePath);
-	const targetSearch = new URLSearchParams(target.search).toString();
-	const currentSearch = routerState.navigationSnapshot.searchParams.toString();
-	return targetPathname === routerState.navigationSnapshot.pathname && targetSearch === currentSearch;
+	return createBasePathStrippedPathAndSearch(target, __basePath) === createSnapshotPathAndSearch(routerState.navigationSnapshot);
 }
 let isPageUnloading = false;
 const RSC_RELOAD_KEY = "__vinext_rsc_initial_reload__";
@@ -724,7 +755,7 @@ function applyRuntimeRscBootstrap(rsc) {
 	if (rsc.nav) restoreHydrationNavigationContext(rsc.nav.pathname, rsc.nav.searchParams, params);
 }
 function registerServerActionCallback() {
-	setServerCallback(async (id, args) => {
+	const serverActionCallback = async (id, args) => {
 		syncServerActionHttpFallbackHead(null);
 		const temporaryReferences = createTemporaryReferenceSet();
 		const actionInitiation = createActionInitiationSnapshot();
@@ -766,6 +797,7 @@ function registerServerActionCallback() {
 			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)) {
@@ -778,7 +810,7 @@ function registerServerActionCallback() {
 			statusText: "OK"
 		}) : fetchResponse;
 		const result = await createFromFetch(Promise.resolve(flightResponse), { temporaryReferences });
-		if (shouldClearClientNavigationCachesForServerActionResult(result, revalidation)) clearClientNavigationCaches();
+		if (revalidation === "none" && shouldClearClientNavigationCachesForServerActionResult(result, revalidation)) clearClientNavigationCaches();
 		if (actionRedirectTarget) {
 			if (isServerActionResult(result) && result.root !== void 0) {
 				const decoded = AppElementsWire.decode(result.root);
@@ -809,6 +841,10 @@ function registerServerActionCallback() {
 			return;
 		}
 		return commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result)), actionInitiation, void 0, revalidation);
+	};
+	setServerCallback((id, args) => {
+		const releaseCacheInvalidationGuard = restorableClientState.beginCacheInvalidationGuard();
+		return Promise.resolve().then(() => serverActionCallback(id, args)).finally(releaseCacheInvalidationGuard);
 	});
 }
 async function main() {
@@ -869,7 +905,8 @@ function bootstrapHydration(rscStream) {
 				consumeAppRouterScrollIntent(scrollIntent ?? null);
 				return browserNavigationController.performHardNavigation(targetHref);
 			};
-			let restoredBfcacheIds = navigationKind === "traverse" ? readCurrentBfcacheVersionHistoryIds(activeTraversalIntent?.historyState ?? window.history.state) : null;
+			let restoredBfcacheIds = navigationKind === "traverse" ? restorableClientState.readCurrentBfcacheVersionHistoryIds(activeTraversalIntent?.historyState ?? window.history.state) : null;
+			const reuseCurrentBfcacheIds = navigationKind !== "traverse" || !restorableClientState.isCacheInvalidationGuarded() && restorableClientState.isCurrentBfcacheVersion(activeTraversalIntent?.historyState ?? window.history.state);
 			try {
 				const shouldUsePendingRouterState = programmaticTransition;
 				if (shouldUsePendingRouterState && hasBrowserRouterState()) pendingRouterState = beginPendingBrowserRouterState();
@@ -934,7 +971,7 @@ function bootstrapHydration(rscStream) {
 						const cachedNavigationSnapshot = createClientNavigationRenderSnapshot(currentHref, cachedParams);
 						const cachedPayload = decodeAppElementsPromise(createFromFetch(Promise.resolve(restoreRscResponse(cachedRoute.response))));
 						if (!browserNavigationController.isCurrentNavigation(navId)) return;
-						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") {
+						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, reuseCurrentBfcacheIds) === "no-commit") {
 							deleteVisitedResponse(rscUrl, requestInterceptionContext);
 							continue;
 						}
@@ -972,7 +1009,7 @@ 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, restoredBfcacheIds).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, reuseCurrentBfcacheIds).catch((error) => {
 									if (browserNavigationController.isCurrentNavigation(navId)) console.error("[vinext] Optimistic RSC navigation error:", error);
 								});
 							}
@@ -1059,7 +1096,7 @@ 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, restoredBfcacheIds) !== "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, reuseCurrentBfcacheIds) !== "committed") return;
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
 					try {
 						const renderedElements = await rscPayload;
@@ -1087,7 +1124,6 @@ function bootstrapHydration(rscStream) {
 			}
 		}
 	});
-	if ("scrollRestoration" in history) history.scrollRestoration = "manual";
 	const handlePopstate = createPopstateRestoreHandler({
 		getActiveNavigationId: browserNavigationController.getActiveNavigationId.bind(browserNavigationController),
 		getPendingNavigation: () => window.__VINEXT_RSC_PENDING__,
@@ -1099,7 +1135,8 @@ function bootstrapHydration(rscStream) {
 		restorePopstateScrollPosition,
 		setPendingNavigation: (pendingNavigation) => {
 			window.__VINEXT_RSC_PENDING__ = pendingNavigation;
-		}
+		},
+		shouldSkipScrollRestore: (navId) => synchronousPopstateScrollRestoreNavigationId === navId
 	});
 	window.addEventListener("popstate", (event) => {
 		const href = window.location.href;
@@ -1110,6 +1147,14 @@ function bootstrapHydration(rscStream) {
 			return;
 		}
 		handlePopstate(event);
+		if (restoreHistoryStateSnapshot(event.state)) restoreSynchronousPopstateScrollPosition({
+			getActiveNavigationId: () => browserNavigationController.getActiveNavigationId(),
+			isCurrentNavigation: (navId) => browserNavigationController.isCurrentNavigation(navId),
+			markScrollRestoreConsumed: (navId) => {
+				synchronousPopstateScrollRestoreNavigationId = navId;
+			},
+			restorePopstateScrollPosition
+		}, event.state);
 	});
 	if (import.meta.hot) {
 		const applyRscHmrUpdate = async (updateId) => {

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

@@ -19,5 +19,6 @@ type ResolveManifestNavigationInterceptionContextOptions = {
  * is owned by the deterministic route graph builder.
  */
 declare function resolveManifestNavigationInterceptionContext(options: ResolveManifestNavigationInterceptionContextOptions): string | null;
+declare function resolveMiddlewareRewriteNavigationInterceptionContext(options: ResolveManifestNavigationInterceptionContextOptions): string | null;
 //#endregion
-export { resolveManifestNavigationInterceptionContext };
+export { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext };

package/dist/server/app-browser-interception-context.js

@@ -1,6 +1,6 @@
 import { splitPathnameForRouteMatch } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
-import { matchRoutePattern, matchRoutePatternPrefix } from "../routing/route-pattern.js";
+import { matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments } from "../routing/route-pattern.js";
 //#region src/server/app-browser-interception-context.ts
 /**
 * Resolve the first-hop interception context from declared route topology.
@@ -26,5 +26,18 @@ function resolveManifestNavigationInterceptionContext(options) {
 	}
 	return null;
 }
+function resolveMiddlewareRewriteNavigationInterceptionContext(options) {
+	if (options.routeManifest === null) return null;
+	const currentPathname = stripBasePath(options.currentPathname, options.basePath);
+	const targetPathname = stripBasePath(options.targetPathname, options.basePath);
+	const sourceParts = splitPathnameForRouteMatch(currentPathname);
+	const targetParts = splitPathnameForRouteMatch(targetPathname);
+	for (const interception of options.routeManifest.segmentGraph.interceptions.values()) {
+		if (!matchRoutePatternPrefix(sourceParts, interception.sourcePatternParts)) continue;
+		if (!matchRoutePatternWithOptionalDynamicSegments(targetParts, interception.targetPatternParts)) continue;
+		return currentPathname;
+	}
+	return null;
+}
 //#endregion
-export { resolveManifestNavigationInterceptionContext };
+export { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext };

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

@@ -35,6 +35,7 @@ type SameUrlServerActionLifecycleOptions = {
   targetHref?: string;
 };
 type BrowserNavigationControllerDeps = {
+  basePath?: string;
   commitClientNavigationState?: typeof commitClientNavigationState;
   performHardNavigation?: (href: string, mode?: HardNavigationMode) => boolean;
   getRouteManifest?: () => RouteManifest | null;
@@ -51,6 +52,12 @@ type BrowserNavigationController = {
   attachBrowserRouterState(setter: Dispatch<AppRouterState | Promise<AppRouterState>>, stateRef: BrowserRouterStateRef): () => void;
   beginPendingBrowserRouterState(): PendingBrowserRouterState;
   finalizeNavigation(navId: number, pending: PendingBrowserRouterState | null | undefined): void;
+  restoreHistorySnapshotVisibleState(options: {
+    beforeCommit?: () => void;
+    navId: number;
+    state: AppRouterState;
+    targetHref: string;
+  }): boolean;
   renderNavigationPayload(options: {
     actionType: "navigate" | "replace" | "traverse";
     createNavigationCommitEffect: BrowserNavigationCommitEffectFactory;
@@ -64,6 +71,7 @@ type BrowserNavigationController = {
     previousNextUrl: string | null;
     scrollIntent?: AppRouterScrollIntent | null;
     restoredBfcacheIds?: Readonly<Record<string, string>> | null;
+    reuseCurrentBfcacheIds?: boolean;
     targetHistoryIndex?: number | null;
     targetHref: string;
     navId: number;
@@ -91,6 +99,8 @@ type BrowserNavigationController = {
   }): ReactNode;
 };
 declare function clearHardNavigationLoopGuard(): void;
+declare function createSnapshotPathAndSearch(snapshot: ClientNavigationRenderSnapshot): string;
+declare function createBasePathStrippedPathAndSearch(url: URL, basePath: string): string;
 declare function createAppBrowserNavigationController(deps?: BrowserNavigationControllerDeps): BrowserNavigationController;
 //#endregion
-export { HistoryUpdateMode, NavigationPayloadOutcome, PendingBrowserRouterState, clearHardNavigationLoopGuard, createAppBrowserNavigationController };
+export { HistoryUpdateMode, NavigationPayloadOutcome, PendingBrowserRouterState, clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch, createSnapshotPathAndSearch };

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

@@ -1,3 +1,4 @@
+import { stripBasePath } from "../utils/base-path.js";
 import { claimAppRouterScrollIntentForCommit, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 import { activateNavigationSnapshot, clearPendingPathname, commitClientNavigationState } from "../shims/navigation.js";
 import { shouldScheduleRefreshForDiscardedServerAction } from "./app-browser-action-result.js";
@@ -49,7 +50,25 @@ function performHardNavigationWithLoopGuard(href, mode = "assign") {
 	else window.location.assign(href);
 	return true;
 }
+function createSnapshotPathAndSearch(snapshot) {
+	const query = snapshot.searchParams.toString();
+	return query === "" ? snapshot.pathname : `${snapshot.pathname}?${query}`;
+}
+function createBasePathStrippedPathAndSearch(url, basePath) {
+	const pathname = stripBasePath(url.pathname, basePath);
+	const query = new URLSearchParams(url.search).toString();
+	return query === "" ? pathname : `${pathname}?${query}`;
+}
+function isSnapshotTargetHref(basePath, snapshot, targetHref) {
+	try {
+		const baseHref = typeof window === "undefined" ? "http://localhost" : window.location.href;
+		return createBasePathStrippedPathAndSearch(new URL(targetHref, baseHref), basePath) === createSnapshotPathAndSearch(snapshot);
+	} catch {
+		return false;
+	}
+}
 function createAppBrowserNavigationController(deps = {}) {
+	const basePath = deps.basePath ?? "";
 	const commitClientNavigationStateImpl = deps.commitClientNavigationState ?? commitClientNavigationState;
 	const performHardNavigation = deps.performHardNavigation ?? performHardNavigationWithLoopGuard;
 	const getRouteManifest = deps.getRouteManifest ?? (() => null);
@@ -215,6 +234,61 @@ function createAppBrowserNavigationController(deps = {}) {
 	function dispatchSynchronousVisibleCommit(commit) {
 		getBrowserRouterStateSetter()(applyApprovedVisibleCommit(getBrowserRouterState(), commit));
 	}
+	function createRestoredHistorySnapshotCommit(options) {
+		const operation = {
+			id: options.renderId,
+			lane: "traverse",
+			startedVisibleCommitVersion: options.currentState.visibleCommitVersion,
+			state: "pending"
+		};
+		return {
+			action: {
+				bfcacheIds: options.restoredState.bfcacheIds,
+				elements: options.restoredState.elements,
+				interception: options.restoredState.interception,
+				interceptionContext: options.restoredState.interceptionContext,
+				layoutFlags: options.restoredState.layoutFlags,
+				layoutIds: options.restoredState.layoutIds,
+				navigationSnapshot: options.restoredState.navigationSnapshot,
+				operation,
+				previousNextUrl: options.restoredState.previousNextUrl,
+				renderId: options.renderId,
+				rootLayoutTreePath: options.restoredState.rootLayoutTreePath,
+				reuseCurrentBfcacheIds: false,
+				routeId: options.restoredState.routeId,
+				skippedLayoutIds: [],
+				slotBindings: options.restoredState.slotBindings,
+				type: "traverse"
+			},
+			interception: options.restoredState.interception,
+			interceptionContext: options.restoredState.interceptionContext,
+			previousNextUrl: options.restoredState.previousNextUrl,
+			rootLayoutTreePath: options.restoredState.rootLayoutTreePath,
+			routeId: options.restoredState.routeId,
+			skippedLayoutIds: []
+		};
+	}
+	function restoreHistorySnapshotVisibleState(options) {
+		if (!isSnapshotTargetHref(basePath, options.state.navigationSnapshot, options.targetHref)) return false;
+		const currentState = getBrowserRouterState();
+		const pending = createRestoredHistorySnapshotCommit({
+			currentState,
+			renderId: allocateRenderId(),
+			restoredState: options.state
+		});
+		const approval = approvePendingNavigationCommit({
+			activeNavigationId,
+			currentState,
+			pending,
+			routeManifest: getRouteManifest(),
+			startedNavigationId: options.navId,
+			targetHref: options.targetHref
+		});
+		if (approval.approvedCommit === null) return false;
+		options.beforeCommit?.();
+		dispatchSynchronousVisibleCommit(approval.approvedCommit);
+		return true;
+	}
 	function notifyDiscardedServerActionRevalidation(lifecycleOptions) {
 		if (!shouldScheduleRefreshForDiscardedServerAction(lifecycleOptions?.revalidation ?? "none")) return;
 		lifecycleOptions?.onDiscardedRevalidation?.();
@@ -237,6 +311,7 @@ function createAppBrowserNavigationController(deps = {}) {
 				previousNextUrl: options.previousNextUrl,
 				renderId,
 				restoredBfcacheIds: options.restoredBfcacheIds,
+				reuseCurrentBfcacheIds: options.reuseCurrentBfcacheIds,
 				type: options.actionType
 			});
 			const approval = approvePendingNavigationCommit({
@@ -354,6 +429,7 @@ function createAppBrowserNavigationController(deps = {}) {
 		attachBrowserRouterState,
 		beginPendingBrowserRouterState,
 		finalizeNavigation,
+		restoreHistorySnapshotVisibleState,
 		renderNavigationPayload,
 		commitSameUrlNavigatePayload,
 		hmrReplaceTree,
@@ -362,4 +438,4 @@ function createAppBrowserNavigationController(deps = {}) {
 	};
 }
 //#endregion
-export { clearHardNavigationLoopGuard, createAppBrowserNavigationController };
+export { clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch, createSnapshotPathAndSearch };

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

@@ -1,17 +1,26 @@
+import { NavigationRuntimeNavigate } from "../client/navigation-runtime.js";
+
 //#region src/server/app-browser-popstate.d.ts
 type RestoreScrollPosition = (state: unknown, options?: {
   shouldContinue?: () => boolean;
 }) => void;
-type NavigateRsc = (href: string, redirectDepth?: number, navigationKind?: "navigate" | "traverse" | "refresh") => Promise<void>;
 type BrowserPopstateRestoreDeps = {
   getActiveNavigationId: () => number;
   getPendingNavigation: () => Promise<void> | null | undefined;
-  getNavigate: () => NavigateRsc | undefined;
+  getNavigate: () => NavigationRuntimeNavigate | undefined;
   isCurrentNavigation: (navId: number) => boolean;
   notifyAppRouterTransitionStart: (href: string) => void;
   restorePopstateScrollPosition: RestoreScrollPosition;
   setPendingNavigation: (pendingNavigation: Promise<void> | null) => void;
+  shouldSkipScrollRestore: (navId: number) => boolean;
 };
+type SynchronousPopstateScrollRestoreDeps = {
+  getActiveNavigationId: () => number;
+  isCurrentNavigation: (navId: number) => boolean;
+  markScrollRestoreConsumed: (navId: number) => void;
+  restorePopstateScrollPosition: RestoreScrollPosition;
+};
+declare function restoreSynchronousPopstateScrollPosition(deps: SynchronousPopstateScrollRestoreDeps, state: unknown): void;
 declare function createPopstateRestoreHandler(deps: BrowserPopstateRestoreDeps): (event: PopStateEvent) => void;
 //#endregion
-export { createPopstateRestoreHandler };
+export { createPopstateRestoreHandler, restoreSynchronousPopstateScrollPosition };

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

@@ -1,7 +1,14 @@
+import { readHistoryStateTraversalIndex } from "./app-history-state.js";
+import "./app-browser-state.js";
 //#region src/server/app-browser-popstate.ts
 function hasSavedScrollPosition(state) {
 	return Boolean(state && typeof state === "object" && "__vinext_scrollY" in state);
 }
+function restoreSynchronousPopstateScrollPosition(deps, state) {
+	const navId = deps.getActiveNavigationId();
+	deps.markScrollRestoreConsumed(navId);
+	deps.restorePopstateScrollPosition(state, { shouldContinue: () => deps.isCurrentNavigation(navId) });
+}
 function scheduleAfterFrame(callback) {
 	if (typeof window !== "undefined" && typeof window.requestAnimationFrame === "function") {
 		window.requestAnimationFrame(callback);
@@ -9,21 +16,29 @@ function scheduleAfterFrame(callback) {
 	}
 	queueMicrotask(callback);
 }
+function createPopstateTraversalIntent(historyState) {
+	return {
+		direction: "unknown",
+		historyState,
+		targetHistoryIndex: readHistoryStateTraversalIndex(historyState)
+	};
+}
 function createPopstateRestoreHandler(deps) {
 	return (event) => {
 		deps.notifyAppRouterTransitionStart(window.location.href);
-		const pendingNavigation = deps.getNavigate()?.(window.location.href, 0, "traverse") ?? Promise.resolve();
+		const pendingNavigation = deps.getNavigate()?.(window.location.href, 0, "traverse", void 0, void 0, false, createPopstateTraversalIntent(event.state)) ?? Promise.resolve();
 		const popstateNavId = deps.getActiveNavigationId();
 		deps.setPendingNavigation(pendingNavigation);
 		const shouldRestoreSavedScroll = hasSavedScrollPosition(event.state);
+		const shouldRestoreScrollForNavigation = () => deps.isCurrentNavigation(popstateNavId) && !deps.shouldSkipScrollRestore(popstateNavId);
 		if (shouldRestoreSavedScroll) scheduleAfterFrame(() => {
-			if (deps.isCurrentNavigation(popstateNavId)) deps.restorePopstateScrollPosition(event.state, { shouldContinue: () => deps.isCurrentNavigation(popstateNavId) });
+			if (shouldRestoreScrollForNavigation()) deps.restorePopstateScrollPosition(event.state, { shouldContinue: shouldRestoreScrollForNavigation });
 		});
 		pendingNavigation.finally(() => {
-			if (deps.isCurrentNavigation(popstateNavId) && !shouldRestoreSavedScroll) deps.restorePopstateScrollPosition(event.state);
+			if (shouldRestoreScrollForNavigation() && !shouldRestoreSavedScroll) deps.restorePopstateScrollPosition(event.state);
 			if (deps.getPendingNavigation() === pendingNavigation) deps.setPendingNavigation(null);
 		});
 	};
 }
 //#endregion
-export { createPopstateRestoreHandler };
+export { createPopstateRestoreHandler, restoreSynchronousPopstateScrollPosition };

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

@@ -49,6 +49,7 @@ type AppRouterAction = {
   previousNextUrl: string | null;
   renderId: number;
   rootLayoutTreePath: string | null;
+  reuseCurrentBfcacheIds: boolean;
   routeId: string;
   skippedLayoutIds: readonly string[];
   slotBindings: readonly AppElementsSlotBinding[];
@@ -102,6 +103,7 @@ declare function createNextBfcacheIdMap(options: {
   elements: AppElements;
   nextPathname: string;
   restored?: BfcacheIdMap | null;
+  reuseCurrent?: boolean;
 }): BfcacheIdMap;
 declare function preserveBfcacheIdsForMergedElements(options: {
   elements: AppElements;
@@ -150,6 +152,7 @@ declare function createPendingNavigationCommit(options: {
   previousNextUrl?: string | null;
   renderId: number;
   restoredBfcacheIds?: BfcacheIdMap | null;
+  reuseCurrentBfcacheIds?: boolean;
   type: "navigate" | "replace" | "traverse";
 }): Promise<PendingNavigationCommit>;
 //#endregion