vinext 1.0.0-beta.9 → 1.0.1

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

@@ -1,45 +1,45 @@
 import { splitPathnameForRouteMatch } from "../routing/utils.js";
 import { addBasePathToPathname, stripBasePath } from "../utils/base-path.js";
-import { VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER } from "./headers.js";
+import { VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER } from "./headers.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import { getMountedSlotIdsHeader, resolveVisitedResponseInterceptionContext } from "./app-elements.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
 import { matchRoutePattern } from "../routing/route-pattern.js";
 import { installWindowNext, setWindowNextInternalSourcePage } from "../client/window-next.js";
 import { retryScrollTo, scrollToHashTargetOnNextFrame } from "../shims/hash-scroll.js";
-import { getBfcacheIdMapContext, setNavigationContext } from "../shims/navigation-context-state.js";
+import { getBfcacheIdMapContext, getNavigationContext, setNavigationContext } from "../shims/navigation-context-state.js";
 import { decodeRedirectError, isRedirectError } from "../shims/navigation-errors.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
 import { clearAppNavigationFailureTarget, installAppNavigationFailureListeners } from "../client/app-nav-failure-handler.js";
 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 } from "../shims/slot.js";
-import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, canonicalizePrewarmableRscRequestHeaders, createCanonicalRscRequestUrl, createRscRequestHeaders, createRscRequestUrl, getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
-import { getNavigationRuntime, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
+import { BfcacheIdentityMapContext, ElementsContext, Slot, bindAppElementsRenderedSearch, setAppElementsRenderedSearch } from "../shims/slot.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import "../client/instrumentation-client.js";
-import { isExternalHistoryState, readHistoryStateActiveRoutePaths, readHistoryStatePreviousNextUrl, resolveActiveRoutePaths } from "./app-history-state.js";
+import { getNavigationRuntime, 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";
 import { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext } from "./app-browser-interception-context.js";
+import { isExternalHistoryState, readHistoryStateActiveRoutePaths, readHistoryStatePreviousNextUrl, resolveActiveRoutePaths } from "./app-history-state.js";
 import { AppBrowserMpaNavigationScheduler } from "./app-browser-mpa-navigation.js";
 import { stripRscCompletionMetadataResponse } from "./rsc-completion-metadata.js";
 import { blockDangerousStreamedRscRedirect } from "./app-browser-rsc-redirect.js";
 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, preloadHybridClientRouteOwner, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveLoadedHybridClientRewriteHref, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, seedPrefetchResponseSnapshot, setClientParams, setMountedSlotsHeader, setPendingPathname, useRouter } from "../shims/navigation.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 { 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";
-import { consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition } from "./app-browser-hydration.js";
+import { consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition, resolveFetchedHydrationLocation } from "./app-browser-hydration.js";
 import { AppBrowserHistoryController } from "./app-browser-history-controller.js";
 import { createVisitedResponseCacheEntry, deleteAllVisitedResponseCacheEntries, deleteInvalidatedHistoryRestoreEntries, deleteVisitedResponseCacheEntry, findVisitedResponseCacheEntry, hasNavigationResponseHistoryLifetime, isVisitedResponseCacheEntryFresh } from "./app-visited-response-cache.js";
 import { createPopstateRestoreHandler, restoreSynchronousPopstateScrollPosition, shouldCommitPopstateUrlWithoutNavigation } from "./app-browser-popstate.js";
-import { createDevOnCaughtError, createOnUncaughtError, createProdOnCaughtError, prodOnRecoverableError } from "./app-browser-error.js";
+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";
@@ -230,7 +230,8 @@ function getMatchedUrlPathname(matchedUrl) {
 }
 function resolvePersistedRefreshInterceptions(state, routeManifest, refreshUrl, requestInterceptionContext) {
 	if (routeManifest === null) return [];
-	const refreshPathParts = splitPathnameForRouteMatch(stripBasePath(refreshUrl.pathname, __basePath));
+	const refreshPathname = stripBasePath(refreshUrl.pathname, __basePath);
+	const refreshPathParts = splitPathnameForRouteMatch(refreshPathname);
 	const resolved = [];
 	for (const binding of state.slotBindings) {
 		if (binding.state !== "active" || !binding.activeRouteId) continue;
@@ -260,21 +261,29 @@ async function fetchPersistedInterceptedSlotRefresh(options) {
 		interceptionId: options.interceptionId,
 		mountedSlotsHeader: options.mountedSlotsHeader
 	});
-	const response = await fetch(await createRscRequestUrl(options.targetPathname, headers), {
+	return decodeSupplementalRefresh(await fetch(await createRscRequestUrl(options.targetPathname, headers), {
 		credentials: "include",
 		headers,
 		signal: options.signal
-	});
-	return decodeAppElementsPromise(createFromFetch(Promise.resolve(response)));
+	}), options.targetPathname);
 }
 async function fetchPersistedSourcePageRefresh(options) {
 	const headers = createRscRequestHeaders({ mountedSlotsHeader: options.mountedSlotsHeader });
-	const response = await fetch(await createRscRequestUrl(options.targetPathname, headers), {
+	return decodeSupplementalRefresh(await fetch(await createRscRequestUrl(options.targetPathname, headers), {
 		credentials: "include",
 		headers,
 		signal: options.signal
-	});
-	return decodeAppElementsPromise(createFromFetch(Promise.resolve(response)));
+	}), options.targetPathname);
+}
+/**
+* Decode a kept branch a refresh fetched from its own URL. Its client pages
+* read the query the server rendered it with, not the navigation's.
+*/
+async function decodeSupplementalRefresh(response, targetPathname) {
+	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);
+	return elements;
 }
 function isSettledPrefetchCacheEntry(entry) {
 	return entry.outcome === "cache-seeded" && entry.pending === void 0 && entry.snapshot !== void 0;
@@ -397,7 +406,7 @@ async function renderNavigationPayload(options) {
 		visibleCommitMode: options.visibleCommitMode ?? "transition"
 	});
 }
-async function commitSameUrlNavigatePayload(nextElements, actionInitiation, returnValue, revalidation = "none") {
+async function commitSameUrlNavigatePayload(nextElements, actionInitiation, returnValue, revalidation = "none", renderedPathAndSearch = null) {
 	let shouldRetrySupplementalRefresh = false;
 	let supplementalHandle = null;
 	if (revalidation !== "none") {
@@ -439,7 +448,7 @@ async function commitSameUrlNavigatePayload(nextElements, actionInitiation, retu
 			});
 		}
 	}
-	const navigationSnapshot = createClientNavigationRenderSnapshot(actionInitiation.href, actionInitiation.routerState.navigationSnapshot.params);
+	const navigationSnapshot = renderedPathAndSearch === null ? withRenderedSearchOf(createClientNavigationRenderSnapshot(actionInitiation.href, actionInitiation.routerState.navigationSnapshot.params), actionInitiation.routerState.navigationSnapshot) : createClientNavigationRenderSnapshot(actionInitiation.href, actionInitiation.routerState.navigationSnapshot.params, renderedPathAndSearch);
 	try {
 		const result = await browserNavigationController.commitSameUrlNavigatePayload(nextElements, navigationSnapshot, returnValue, actionInitiation.routerState, {
 			onDiscardedRevalidation() {
@@ -712,7 +721,8 @@ function BrowserRoot({ hydrationCachePublication, initialElements, initialNaviga
 	const routeTree = createElement(RedirectBoundary, null, createElement(NavigationCommitSignal, { renderId: treeState.renderId }, createElement(ElementsContext.Provider, { value: treeState.elements }, createElement(Slot, { id: treeState.routeId }))));
 	const bfcacheSegmentIdentities = useMemo(() => createBfcacheSegmentIdentityMap({ elements: treeState.elements }), [treeState.elements]);
 	const identityMapTree = createElement(BfcacheIdentityMapContext.Provider, { value: bfcacheSegmentIdentities }, routeTree);
-	const redirectedTree = createElement(AppRouterRedirectBridge, null, BfcacheIdMapContext ? createElement(BfcacheIdMapContext.Provider, { value: treeState.bfcacheIds }, identityMapTree) : identityMapTree);
+	const bfcacheTree = BfcacheIdMapContext ? createElement(BfcacheIdMapContext.Provider, { value: treeState.bfcacheIds }, identityMapTree) : identityMapTree;
+	const redirectedTree = createElement(AppRouterRedirectBridge, null, bfcacheTree);
 	const innerTree = AppRouterContext ? createElement(AppRouterContext.Provider, { value: appRouterInstance }, redirectedTree) : redirectedTree;
 	const committedTree = import.meta.env.DEV ? createElement(DevRecoveryBoundary, {
 		isImplicitRootErrorBoundary: true,
@@ -738,6 +748,38 @@ function restoreHydrationNavigationContext(pathname, searchParams, params) {
 function restoreEmbeddedHydrationNavigationContext(pathname, searchParams, params, searchParamsFromBrowser) {
 	restoreHydrationNavigationContext(pathname, searchParamsFromBrowser ? window.location.search : searchParams, params);
 }
+/**
+* The path and query SSR rendered, from the navigation payload the document
+* embeds: the effective query, which a rewrite may have changed, or the
+* browser URL's when a stored document leaves the query out.
+*/
+function getHydrationRenderedPathAndSearch() {
+	const context = getNavigationContext();
+	if (!context) return null;
+	const search = context.searchParams.toString();
+	return search ? `${context.pathname}?${search}` : context.pathname;
+}
+/**
+* A render that turns dynamic after the head sends its client pages' query
+* later in the document (see `app-ssr-entry.ts`), possibly after bootstrap, so
+* the hydration snapshot reads it when a client page first renders.
+*/
+function withLateRenderedSearch(snapshot, rsc) {
+	if (!rsc) return snapshot;
+	const headRenderedSearch = snapshot.renderedSearch;
+	return Object.defineProperty(snapshot, "renderedSearch", {
+		configurable: true,
+		enumerable: true,
+		get: () => rsc.renderedSearch ?? headRenderedSearch
+	});
+}
+/** Carry the rendered query over to a snapshot of the same URL. */
+function withRenderedSearchOf(snapshot, source) {
+	return source.renderedSearch === void 0 ? snapshot : {
+		...snapshot,
+		renderedSearch: source.renderedSearch
+	};
+}
 function restorePopstateScrollPosition(state, options) {
 	const shouldContinue = options?.shouldContinue ?? (() => true);
 	if (!shouldContinue()) return;
@@ -746,7 +788,8 @@ function restorePopstateScrollPosition(state, options) {
 		return;
 	}
 	const y = Number(state.__vinext_scrollY);
-	retryScrollTo("__vinext_scrollX" in state ? Number(state.__vinext_scrollX) : 0, y, {
+	const x = "__vinext_scrollX" in state ? Number(state.__vinext_scrollX) : 0;
+	retryScrollTo(x, y, {
 		minFrames: 1,
 		shouldContinue
 	});
@@ -825,7 +868,8 @@ async function readInitialRscStream() {
 	if (parsedParams) try {
 		applyClientParams(parsedParams);
 	} catch {}
-	restoreHydrationNavigationContext(window.location.pathname, window.location.search, params);
+	const rendered = resolveFetchedHydrationLocation(parseRenderedPathAndSearchHeader(rscResponse.headers.get(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER)), window.location);
+	restoreHydrationNavigationContext(rendered.pathname, rendered.search, params);
 	return rscResponse.body;
 }
 function applyRuntimeRscBootstrap(rsc) {
@@ -845,14 +889,16 @@ function registerServerActionCallback() {
 			navigationPlanner,
 			performHardNavigation: (url, historyMode) => browserNavigationController.performHardNavigation(url, historyMode),
 			renderRedirectPayload(elements, target, actionInitiation, revalidation) {
+				if (browserNavigationController.isCurrentNavigation(actionInitiation.navigationId)) getNavigationRuntime()?.functions.notifyLinkNavigationStart?.();
 				const hashIdx = target.href.indexOf("#");
-				const actionScrollIntent = beginAppRouterScrollIntent((hashIdx !== -1 ? target.href.slice(hashIdx) : "") || null);
+				const hash = hashIdx !== -1 ? target.href.slice(hashIdx) : "";
+				const actionScrollIntent = beginAppRouterScrollIntent(hash || null);
 				if (target.type === "push") saveScrollPosition();
 				renderNavigationPayload({
 					actionType: target.type === "push" ? "navigate" : "replace",
 					historyUpdateMode: target.type === "push" ? "push" : "replace",
 					navigationInitiationState: actionInitiation.routerState,
-					navigationSnapshot: createClientNavigationRenderSnapshot(target.href, actionInitiation.routerState.navigationSnapshot.params),
+					navigationSnapshot: createClientNavigationRenderSnapshot(target.href, actionInitiation.routerState.navigationSnapshot.params, target.renderedPathAndSearch),
 					navId: actionInitiation.navigationId,
 					operationLane: resolveServerActionOperationLane(revalidation),
 					params: {},
@@ -892,8 +938,11 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 	const hydrationCachePublication = createHydrationCachePublication();
 	const cacheGeneration = clientNavigationCacheGeneration;
 	const [reactBranch, cacheBranch] = rscStream.tee();
-	const root = decodeAppElementsPromise(createFromReadableStream(reactBranch));
-	const initialNavigationSnapshot = createClientNavigationRenderSnapshot(window.location.href, latestClientParams);
+	const initialNavigationSnapshot = withLateRenderedSearch(createClientNavigationRenderSnapshot(window.location.href, latestClientParams, getHydrationRenderedPathAndSearch()), initialRscBootstrap);
+	const root = decodeAppElementsPromise(createFromReadableStream(reactBranch)).then((elements) => {
+		bindAppElementsRenderedSearch(elements, initialNavigationSnapshot);
+		return elements;
+	});
 	const initialParams = initialNavigationSnapshot.params;
 	const initialPathAndSearch = createSnapshotPathAndSearch(initialNavigationSnapshot);
 	const initialCacheBuffer = new Response(cacheBranch).arrayBuffer();
@@ -935,10 +984,9 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 		hydrationCachePublication.fail();
 		reportUncaughtError(...args);
 	};
-	const onRecoverableError = (...args) => {
+	const onRecoverableError = createProdOnRecoverableError(() => {
 		hydrationCachePublication.fail();
-		prodOnRecoverableError(...args);
-	};
+	});
 	const invalidateOnCaughtError = (handler) => ((...args) => {
 		hydrationCachePublication.fail();
 		handler(...args);
@@ -1084,13 +1132,12 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						navigationKind,
 						targetPathAndSearch
 					});
-					const usesCanonicalPrewarmedRequest = !IS_STATIC_EXPORT && process.env.__VINEXT_CANONICAL_RSC_REQUESTS === "1" && navigationKind === "navigate" && settledPrefetchedResponse === null && requestInterceptionContext === null && mountedSlotsHeader === null && (rewrittenNavigationHref === null || rewrittenNavigationHref === currentHref) && canonicalizePrewarmableRscRequestHeaders(requestHeaders);
 					const rscUrl = settledPrefetchedResponse ? resolvePrefetchNavigationResponseUrl({
 						additionalRscUrls: additionalPrefetchPathAndSearch,
 						origin: window.location.origin,
 						responseUrl: settledPrefetchedResponse.url,
 						visibleRscUrl: targetPathAndSearch
-					}) : usesCanonicalPrewarmedRequest ? createCanonicalRscRequestUrl(targetPathAndSearch) : await createRscRequestUrl(targetPathAndSearch, requestHeaders);
+					}) : await createRscRequestUrl(targetPathAndSearch, requestHeaders);
 					const additionalPrefetchRscUrls = settledPrefetchedResponse ? additionalPrefetchPathAndSearch : await Promise.all(additionalPrefetchPathAndSearch.map((href) => createRscRequestUrl(href, requestHeaders)));
 					const visitedResponseCandidate = shouldBypassNavigationCache ? {
 						cacheKey: AppElementsWire.encodeCacheKey(rscUrl, requestInterceptionContext),
@@ -1135,7 +1182,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 							redirectDepth: redirectCount,
 							requestPreviousNextUrl,
 							responseOk: true,
-							responseUrl: cachedRoute.response.url,
+							responseUrl: IS_STATIC_EXPORT ? currentHref : cachedRoute.response.url,
 							source: "cached",
 							streamedRedirectTarget: null
 						});
@@ -1154,7 +1201,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						}
 						if (!browserNavigationController.isCurrentNavigation(navId)) return;
 						const cachedParams = cachedRoute.params;
-						const cachedNavigationSnapshot = createClientNavigationRenderSnapshot(currentHref, cachedParams);
+						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({
@@ -1276,7 +1323,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						}
 					}
 					if (!navResponse) {
-						if (navigationKind === "navigate" && !usesCanonicalPrewarmedRequest) {
+						if (navigationKind === "navigate") {
 							const clientReuseManifestHeader = createClientReuseManifestHeaderFromVisibleAppState(navigationInitiationState);
 							if (clientReuseManifestHeader !== null) requestHeaders.set(VINEXT_CLIENT_REUSE_MANIFEST_HEADER, clientReuseManifestHeader);
 						}
@@ -1329,7 +1376,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					}
 					if (!hasSupplementalRefresh) navigationAbortHandle.release();
 					const navParams = parseEncodedJsonHeader(navResponse.headers.get("X-Vinext-Params")) ?? (IS_STATIC_EXPORT ? resolveStaticExportRouteParams(currentHref) : {});
-					const navigationSnapshot = createClientNavigationRenderSnapshot(currentHref, navParams);
+					const navigationSnapshot = createClientNavigationRenderSnapshot(currentHref, navParams, parseRenderedPathAndSearchHeader(navResponse.headers.get(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER)));
 					const navBody = navResponse.body;
 					if (!navBody) return;
 					const [reactBranch, cacheBranch] = navBody.tee();
@@ -1360,6 +1407,8 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 							primary: Promise.resolve(rscPayload),
 							signal: navigationAbortHandle.signal,
 							supplemental
+						}).finally(() => {
+							navigationAbortHandle.release();
 						}).then(requireCompleteSupplementalRefresh);
 					}
 					if (IS_STATIC_EXPORT) {
@@ -1521,10 +1570,16 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 			if (updateId !== latestRscHmrUpdateId) return;
 			if (!browserNavigationController.hasBrowserRouterState()) return;
 			clearClientNavigationCaches();
-			const navigationSnapshot = createClientNavigationRenderSnapshot(window.location.href, latestClientParams);
 			devErrorOverlay?.dismissOverlay();
 			const hmrHeaders = createRscRequestHeaders({ mountedSlotsHeader: getMountedSlotIdsHeader(browserNavigationController.getBrowserRouterState().elements) });
-			await browserNavigationController.hmrReplaceTree(decodeAppElementsPromise(createFromFetch(fetch(await createRscRequestUrl(window.location.pathname + window.location.search, hmrHeaders), { headers: hmrHeaders }).then(stripRscCompletionMetadataResponse))), navigationSnapshot);
+			const hmrHref = window.location.href;
+			const hmrParams = latestClientParams;
+			const sameQuerySnapshot = withRenderedSearchOf(createClientNavigationRenderSnapshot(hmrHref, hmrParams), browserNavigationController.getBrowserRouterState().navigationSnapshot);
+			const hmrResponse = fetch(await createRscRequestUrl(window.location.pathname + window.location.search, hmrHeaders), { headers: hmrHeaders });
+			await browserNavigationController.hmrReplaceTree(decodeAppElementsPromise(createFromFetch(hmrResponse.then(stripRscCompletionMetadataResponse))), hmrResponse.then((response) => {
+				const renderedPathAndSearch = parseRenderedPathAndSearchHeader(response.headers.get(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER));
+				return renderedPathAndSearch === null ? sameQuerySnapshot : createClientNavigationRenderSnapshot(hmrHref, hmrParams, renderedPathAndSearch);
+			}));
 		};
 		const handleRscUpdate = async (updateId) => {
 			try {

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

@@ -4,9 +4,8 @@ type VinextHydrateRootErrorInfo = {
   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 prodOnRecoverableError(error: unknown): void;
-//#endregion
-export { createDevOnCaughtError, createOnUncaughtError, createProdOnCaughtError, prodOnRecoverableError };
+export declare function createOnUncaughtError(): 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

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

@@ -1,5 +1,6 @@
 import { isUnknownRecord } from "../utils/record.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
+import { isBailoutToCSRError } from "../shims/navigation-errors.js";
 //#region src/server/app-browser-error.ts
 function isImplicitRootErrorBoundary(errorInfo) {
 	if (!isUnknownRecord(errorInfo.errorBoundary)) return false;
@@ -41,8 +42,13 @@ function createDevOnCaughtError(onCaughtError, onImplicitRootError) {
 		onCaughtError(error, errorInfo);
 	};
 }
-function prodOnRecoverableError(error) {
-	reportGlobalError(error instanceof Error && error.cause !== void 0 ? error.cause : error);
+function createProdOnRecoverableError(onReportedError) {
+	return (error) => {
+		const cause = error instanceof Error && error.cause !== void 0 ? error.cause : error;
+		if (isBailoutToCSRError(cause)) return;
+		onReportedError();
+		reportGlobalError(cause);
+	};
 }
 //#endregion
-export { createDevOnCaughtError, createOnUncaughtError, createProdOnCaughtError, prodOnRecoverableError };
+export { createDevOnCaughtError, createOnUncaughtError, createProdOnCaughtError, createProdOnRecoverableError };

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

@@ -32,7 +32,7 @@ type AppBrowserHistoryControllerDeps = {
  * `AppBrowserNavigationController.restoreHistorySnapshotVisibleState()` call and
  * the `ApprovedVisibleCommit` boundary.
  */
-type RestorableSnapshotCandidate = {
+export type RestorableSnapshotCandidate = {
   state: AppRouterState;
   beforeCommit: () => void;
 };
@@ -51,7 +51,7 @@ type CommitNavigationHistoryOptions = {
   targetHistoryIndex?: number | null;
   stageClientParams: () => void;
 };
-declare function createCanonicalBrowserHistoryHref(href: string): string;
+export declare function createCanonicalBrowserHistoryHref(href: string): string;
 /**
  * Owns App Router browser-history metadata and traversal bookkeeping behind a
  * typed seam: traversal index allocation/commit, push/replace/traverse/hash-only
@@ -65,7 +65,7 @@ declare function createCanonicalBrowserHistoryHref(href: string): string;
  * `applyApprovedVisibleCommit()`, and never bypasses the `ApprovedVisibleCommit`
  * boundary owned by `AppBrowserNavigationController`.
  */
-declare class AppBrowserHistoryController {
+export declare class AppBrowserHistoryController {
   #private;
   constructor(deps: AppBrowserHistoryControllerDeps);
   get currentHistoryTraversalIndex(): number | null;
@@ -119,5 +119,4 @@ declare class AppBrowserHistoryController {
    */
   restoreHistorySnapshot(options: RestoreHistorySnapshotOptions): boolean;
 }
-//#endregion
-export { AppBrowserHistoryController, RestorableSnapshotCandidate, createCanonicalBrowserHistoryHref };
+//#endregion

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

@@ -1,3 +1,4 @@
+import { RSC_FORM_STATE_GLOBAL } from "../client/browser-globals.js";
 import { ReactFormState, hydrateRoot } from "react-dom/client";
 //#region src/server/app-browser-hydration.d.ts
 type HydrateRootOptions = NonNullable<Parameters<typeof hydrateRoot>[2]>;
@@ -9,23 +10,32 @@ type HydrateRootCaughtErrorHandler = NonNullable<HydrateRootOptions["onCaughtErr
 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 = {
   [RSC_FORM_STATE_GLOBAL]?: ReactFormState;
 };
-declare function consumeInitialFormState(global: FormStateGlobal): ReactFormState | null;
-declare function createVinextHydrateRootOptions(options: {
+export declare function consumeInitialFormState(global: FormStateGlobal): ReactFormState | null;
+export declare function createVinextHydrateRootOptions(options: {
   formState: ReactFormState | null;
   onCaughtError?: HydrateRootCaughtErrorHandler;
   onRecoverableError?: HydrateRootRecoverableErrorHandler;
   onUncaughtError: HydrateRootUncaughtErrorHandler;
 }): HydrateRootOptions;
-declare function hydrateRootInTransition(options: {
+export declare function hydrateRootInTransition(options: {
   children: HydrateRootChildren;
   container: HydrateRootContainer;
   hydrateRoot: HydrateRoot;
   options: HydrateRootOptions;
   startTransition: StartTransition;
 }): HydrateRootReturn;
-//#endregion
-export { RSC_FORM_STATE_GLOBAL, consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition };
+/**
+ * The pathname and query to hydrate with when the initial Flight payload is
+ * fetched instead of embedded, matching what SSR rendered: the query the
+ * server rendered (`X-Vinext-Rendered-Path-And-Search`), which a rewrite may
+ * have changed, under the public pathname `usePathname()` exposes. The
+ * header's path is the rewrite target, so it is never the pathname.
+ */
+export declare function resolveFetchedHydrationLocation(renderedPathAndSearch: string | null, location: Pick<Location, "origin" | "pathname" | "search">): {
+  pathname: string;
+  search: string;
+};
+//#endregion

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

@@ -1,5 +1,5 @@
+import { RSC_FORM_STATE_GLOBAL } from "../client/browser-globals.js";
 //#region src/server/app-browser-hydration.ts
-const RSC_FORM_STATE_GLOBAL = "__VINEXT_RSC_FORM_STATE__";
 function consumeInitialFormState(global) {
 	const formState = global["__VINEXT_RSC_FORM_STATE__"] ?? null;
 	delete global[RSC_FORM_STATE_GLOBAL];
@@ -25,5 +25,18 @@ function hydrateRootInTransition(options) {
 	if (root === void 0) throw new Error("[vinext] React.startTransition did not synchronously start hydration");
 	return root;
 }
+/**
+* The pathname and query to hydrate with when the initial Flight payload is
+* fetched instead of embedded, matching what SSR rendered: the query the
+* server rendered (`X-Vinext-Rendered-Path-And-Search`), which a rewrite may
+* have changed, under the public pathname `usePathname()` exposes. The
+* header's path is the rewrite target, so it is never the pathname.
+*/
+function resolveFetchedHydrationLocation(renderedPathAndSearch, location) {
+	return {
+		pathname: location.pathname,
+		search: renderedPathAndSearch === null ? location.search : new URL(renderedPathAndSearch, location.origin).search
+	};
+}
 //#endregion
-export { RSC_FORM_STATE_GLOBAL, consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition };
+export { consumeInitialFormState, createVinextHydrateRootOptions, hydrateRootInTransition, resolveFetchedHydrationLocation };

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

@@ -18,7 +18,6 @@ type ResolveManifestNavigationInterceptionContextOptions = {
  * When multiple manifest interceptions match, the first one wins. That order
  * 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, resolveMiddlewareRewriteNavigationInterceptionContext };
+export declare function resolveManifestNavigationInterceptionContext(options: ResolveManifestNavigationInterceptionContextOptions): string | null;
+export declare function resolveMiddlewareRewriteNavigationInterceptionContext(options: ResolveManifestNavigationInterceptionContextOptions): string | null;
+//#endregion

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

@@ -1,15 +1,14 @@
 import { HistoryUpdateMode } from "./app-browser-navigation-controller.js";
 //#region src/server/app-browser-mpa-navigation.d.ts
-type AppBrowserMpaNavigationWindow = {
+export type AppBrowserMpaNavigationWindow = {
   location: Pick<Location, "assign" | "replace">;
   requestAnimationFrame?: (callback: FrameRequestCallback) => unknown;
   setTimeout(callback: () => void, timeout: number): unknown;
 };
-declare function hasPendingAppRouterPageRedirect(targetDocument: unknown): boolean;
-declare class AppBrowserMpaNavigationScheduler {
+export declare function hasPendingAppRouterPageRedirect(targetDocument: unknown): boolean;
+export declare class AppBrowserMpaNavigationScheduler {
   #private;
   reset(): void;
   navigate(targetWindow: AppBrowserMpaNavigationWindow, href: string, historyUpdateMode: HistoryUpdateMode): void;
 }
-//#endregion
-export { AppBrowserMpaNavigationScheduler, AppBrowserMpaNavigationWindow, hasPendingAppRouterPageRedirect };
+//#endregion

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

@@ -1,5 +1,5 @@
 //#region src/server/app-browser-navigation-abort.d.ts
-type AppBrowserNavigationAbortHandle = {
+export type AppBrowserNavigationAbortHandle = {
   release(): void;
   signal: AbortSignal;
 };
@@ -8,9 +8,8 @@ type AppBrowserNavigationAbortHandle = {
  * Once a Flight response is handed to React, release the handle so a newer
  * navigation does not abort the response body while React is decoding it.
  */
-declare function createAppBrowserNavigationAbortCoordinator(): {
+export declare function createAppBrowserNavigationAbortCoordinator(): {
   abortActive(): void;
   begin(): AppBrowserNavigationAbortHandle;
 };
-//#endregion
-export { AppBrowserNavigationAbortHandle, createAppBrowserNavigationAbortCoordinator };
+//#endregion

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

@@ -9,13 +9,13 @@ import { ClientNavigationRenderSnapshot, commitClientNavigationState, createSnap
 import { AppNavigationPayloadOrigin, AppRouterState } from "./app-browser-state.js";
 import { Dispatch, ReactNode } from "react";
 //#region src/server/app-browser-navigation-controller.d.ts
-type HistoryUpdateMode = "push" | "replace";
-type PendingBrowserRouterState = {
+export type HistoryUpdateMode = "push" | "replace";
+export type PendingBrowserRouterState = {
   promise: Promise<AppRouterState>;
   resolve: (state: AppRouterState) => void;
   settled: boolean;
 };
-type NavigationPayloadOutcome = "committed" | "no-commit" | "hard-navigate";
+export type NavigationPayloadOutcome = "committed" | "no-commit" | "hard-navigate";
 type HardNavigationMode = "assign" | "replace";
 type BrowserNavigationCommitEffect = () => void;
 type BrowserNavigationCommitEffectFactory = (options: {
@@ -90,7 +90,7 @@ type BrowserNavigationController = {
     ok: boolean;
     data: unknown;
   }, actionInitiationState?: AppRouterState, lifecycleOptions?: SameUrlServerActionLifecycleOptions): Promise<unknown>;
-  hmrReplaceTree(nextElements: Promise<AppElements>, navigationSnapshot: ClientNavigationRenderSnapshot): Promise<void>;
+  hmrReplaceTree(nextElements: Promise<AppElements>, navigationSnapshot: ClientNavigationRenderSnapshot | Promise<ClientNavigationRenderSnapshot>): Promise<void>;
   /**
    * Force-drain the queued pre-paint effect for the given renderId without
    * waiting for NavigationCommitSignal to commit. Used by the dev recovery
@@ -107,8 +107,8 @@ type BrowserNavigationController = {
     children?: ReactNode;
   }): ReactNode;
 };
-declare function clearHardNavigationLoopGuard(): void;
-declare function createBasePathStrippedPathAndSearch(url: URL, basePath: string): string;
-declare function createAppBrowserNavigationController(deps?: BrowserNavigationControllerDeps): BrowserNavigationController;
+export declare function clearHardNavigationLoopGuard(): void;
+export declare function createBasePathStrippedPathAndSearch(url: URL, basePath: string): string;
+export declare function createAppBrowserNavigationController(deps?: BrowserNavigationControllerDeps): BrowserNavigationController;
 //#endregion
-export { HistoryUpdateMode, NavigationPayloadOutcome, PendingBrowserRouterState, clearHardNavigationLoopGuard, createAppBrowserNavigationController, createBasePathStrippedPathAndSearch, createSnapshotPathAndSearch };
+export { createSnapshotPathAndSearch };

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

@@ -1,8 +1,8 @@
 import { stripBasePath } from "../utils/base-path.js";
 import { clearAppNavigationFailureTarget, getAppNavigationFailureTarget } from "../client/app-nav-failure-handler.js";
 import { claimAppRouterScrollIntentForCommit, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
-import { resolveActiveRoutePaths } from "./app-history-state.js";
 import { resolveServerActionOperationLane, shouldScheduleRefreshForDiscardedServerAction } from "./app-browser-action-result.js";
+import { resolveActiveRoutePaths } from "./app-history-state.js";
 import { activateNavigationSnapshot, clearPendingPathname, commitClientNavigationState, createSnapshotPathAndSearch } from "../shims/navigation.js";
 import { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, createPendingNavigationCommit, createPendingNavigationCommitFromElements } from "./app-browser-state.js";
 import { applyApprovedVisibleCommit, approveHmrVisibleCommit, approvePendingNavigationCommit, resolveAndClassifyNavigationCommit } from "./app-browser-visible-commit.js";
@@ -210,17 +210,20 @@ function createAppBrowserNavigationController(deps = {}) {
 			clearAppNavigationFailureTarget(targetHref);
 		}
 	}
-	async function hmrReplaceTree(nextElements, navigationSnapshot) {
+	async function hmrReplaceTree(nextElements, pendingNavigationSnapshot) {
 		const hmrUpdateId = ++latestHmrUpdateId;
 		const startedDuringUserNavigation = pendingUserNavigationLane === "navigation";
 		if (!hasBrowserRouterState()) return;
+		const currentState = getBrowserRouterState();
+		const renderId = allocateRenderId();
+		const [navigationSnapshot] = await Promise.all([pendingNavigationSnapshot, nextElements]);
 		const pending = await createPendingNavigationCommit({
-			currentState: getBrowserRouterState(),
+			currentState,
 			nextElements,
 			navigationSnapshot,
 			operationLane: "hmr",
 			payloadOrigin: FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN,
-			renderId: allocateRenderId(),
+			renderId,
 			type: "replace"
 		});
 		if (hmrUpdateId !== latestHmrUpdateId || startedDuringUserNavigation) return;
@@ -337,7 +340,8 @@ function createAppBrowserNavigationController(deps = {}) {
 		return true;
 	}
 	function notifyDiscardedServerActionRevalidation(lifecycleOptions) {
-		if (!shouldScheduleRefreshForDiscardedServerAction(lifecycleOptions?.revalidation ?? "none")) return;
+		const revalidation = lifecycleOptions?.revalidation ?? "none";
+		if (!shouldScheduleRefreshForDiscardedServerAction(revalidation)) return;
 		lifecycleOptions?.onDiscardedRevalidation?.();
 	}
 	function isSamePathSearchHashCommit(targetHref) {

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

@@ -1,11 +1,10 @@
 import { ClientNavigationRenderSnapshot } from "../shims/navigation.js";
 //#region src/server/app-browser-navigation-response.d.ts
-declare function shouldRecoverSamePathSearchCommitOnResponseCompletion(options: {
+export declare function shouldRecoverSamePathSearchCommitOnResponseCompletion(options: {
   basePath: string;
   currentSnapshot: ClientNavigationRenderSnapshot;
   navigationKind: "navigate" | "traverse" | "refresh";
   programmaticTransition: boolean;
   targetUrl: URL;
 }): boolean;
-//#endregion
-export { shouldRecoverSamePathSearchCommitOnResponseCompletion };
+//#endregion

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

@@ -19,12 +19,11 @@ type SynchronousPopstateScrollRestoreDeps = {
   markScrollRestoreConsumed: (navId: number) => void;
   restorePopstateScrollPosition: RestoreScrollPosition;
 };
-declare function restoreSynchronousPopstateScrollPosition(deps: SynchronousPopstateScrollRestoreDeps, state: unknown): void;
-declare function shouldCommitPopstateUrlWithoutNavigation(options: {
+export declare function restoreSynchronousPopstateScrollPosition(deps: SynchronousPopstateScrollRestoreDeps, state: unknown): void;
+export declare function shouldCommitPopstateUrlWithoutNavigation(options: {
   historyState: unknown;
   isCurrentExternalHistoryTree: boolean;
   isSameAppRouteTarget: boolean;
 }): boolean;
-declare function createPopstateRestoreHandler(deps: BrowserPopstateRestoreDeps): (event: PopStateEvent) => void;
-//#endregion
-export { createPopstateRestoreHandler, restoreSynchronousPopstateScrollPosition, shouldCommitPopstateUrlWithoutNavigation };
+export declare function createPopstateRestoreHandler(deps: BrowserPopstateRestoreDeps): (event: PopStateEvent) => void;
+//#endregion