vinext 1.0.0-beta.8 → 1.0.0

package/dist/server/app-browser-action-result.d.ts

@@ -1,14 +1,14 @@
 import { OperationLane } from "./operation-token.js";
 import { ServerActionResultFacts } from "./navigation-planner.js";
 //#region src/server/app-browser-action-result.d.ts
-type AppBrowserServerActionResult<TRoot> = {
+export type AppBrowserServerActionResult<TRoot> = {
   root?: TRoot;
   returnValue?: {
     ok: boolean;
     data: unknown;
   };
 };
-type ServerActionRevalidationKind = "dynamicOnly" | "none" | "staticAndDynamic";
+export type ServerActionRevalidationKind = "dynamicOnly" | "none" | "staticAndDynamic";
 type ServerActionInitiationSnapshot<TRouterState> = {
   href: string;
   navigationId: number;
@@ -21,14 +21,14 @@ type ServerActionInitiationSnapshot<TRouterState> = {
  * `slot:`, `__route`, etc.) and will never collide with these property names.
  * If the wire format ever adds a `"root"` key, this guard must be updated.
  */
-declare function isServerActionResult<TRoot>(value: unknown): value is AppBrowserServerActionResult<TRoot>;
-declare function shouldClearClientNavigationCachesForServerActionResult<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot, revalidation?: ServerActionRevalidationKind): boolean;
-declare function parseServerActionRevalidationHeader(headers: Pick<Headers, "get">): ServerActionRevalidationKind;
-declare function resolveServerActionOperationLane(revalidation: ServerActionRevalidationKind): Extract<OperationLane, "refresh" | "server-action">;
-declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): unknown;
-declare function shouldSyncServerActionHttpFallbackHead<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot): boolean;
-declare function readInvalidServerActionResponseError(response: Pick<Response, "headers" | "status" | "text">, hasRedirectLocation: boolean): Promise<Error | null>;
-type ServerActionResultResponseFactsInput = {
+export declare function isServerActionResult<TRoot>(value: unknown): value is AppBrowserServerActionResult<TRoot>;
+export declare function shouldClearClientNavigationCachesForServerActionResult<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot, revalidation?: ServerActionRevalidationKind): boolean;
+export declare function parseServerActionRevalidationHeader(headers: Pick<Headers, "get">): ServerActionRevalidationKind;
+export declare function resolveServerActionOperationLane(revalidation: ServerActionRevalidationKind): Extract<OperationLane, "refresh" | "server-action">;
+export declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): unknown;
+export declare function shouldSyncServerActionHttpFallbackHead<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot): boolean;
+export declare function readInvalidServerActionResponseError(response: Pick<Response, "headers" | "status" | "text">, hasRedirectLocation: boolean): Promise<Error | null>;
+export type ServerActionResultResponseFactsInput = {
   actionRedirectHref: string | null;
   actionRedirectType: string | null;
   clientCompatibilityId: string | null;
@@ -44,9 +44,9 @@ type ServerActionResultResponseFactsInput = {
  * normalisation and RSC content-type detection happen for server-action
  * compatibility checks.
  */
-declare function createServerActionResultFacts(input: ServerActionResultResponseFactsInput): ServerActionResultFacts;
-declare function shouldScheduleRefreshForDiscardedServerAction(revalidation: ServerActionRevalidationKind): boolean;
-declare function createServerActionInitiationSnapshot<TRouterState>(options: {
+export declare function createServerActionResultFacts(input: ServerActionResultResponseFactsInput): ServerActionResultFacts;
+export declare function shouldScheduleRefreshForDiscardedServerAction(revalidation: ServerActionRevalidationKind): boolean;
+export declare function createServerActionInitiationSnapshot<TRouterState>(options: {
   href: string;
   navigationId: number;
   origin?: string;
@@ -61,6 +61,5 @@ type DiscardedServerActionRefreshSchedulerOptions = {
   queueTask?: (callback: () => void) => void;
   runRefresh: () => void;
 };
-declare function createDiscardedServerActionRefreshScheduler(options: DiscardedServerActionRefreshSchedulerOptions): DiscardedServerActionRefreshScheduler;
-//#endregion
-export { AppBrowserServerActionResult, ServerActionResultResponseFactsInput, ServerActionRevalidationKind, createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, resolveServerActionOperationLane, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction, shouldSyncServerActionHttpFallbackHead };
+export declare function createDiscardedServerActionRefreshScheduler(options: DiscardedServerActionRefreshSchedulerOptions): DiscardedServerActionRefreshScheduler;
+//#endregion

package/dist/server/app-browser-client-reuse-manifest.d.ts

@@ -6,6 +6,5 @@ type VisibleAppState = Pick<AppRouterState, "elements" | "visibleCommitVersion">
 type CreateClientReuseManifestHeaderOptions = Readonly<{
   limits?: ClientReuseManifestLimits;
 }>;
-declare function createClientReuseManifestHeaderFromVisibleAppState(state: VisibleAppState, options?: CreateClientReuseManifestHeaderOptions): string | null;
-//#endregion
-export { createClientReuseManifestHeaderFromVisibleAppState };
+export declare function createClientReuseManifestHeaderFromVisibleAppState(state: VisibleAppState, options?: CreateClientReuseManifestHeaderOptions): string | null;
+//#endregion

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

@@ -1,48 +1,48 @@
 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 { 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 { getNavigationRuntime, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import "../client/instrumentation-client.js";
-import { resolveManifestNavigationInterceptionContext, resolveMiddlewareRewriteNavigationInterceptionContext } from "./app-browser-interception-context.js";
 import { isExternalHistoryState, readHistoryStateActiveRoutePaths, readHistoryStatePreviousNextUrl, resolveActiveRoutePaths } from "./app-history-state.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 { 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 { 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 { 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, resolveOptimisticNavigationPayload } from "./app-optimistic-routing.js";
+import { canCommitOptimisticRouteTemplate, createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, matchOptimisticRouteManifestRoute, resolveOptimisticNavigationParamsForHref, resolveOptimisticNavigationPayload } from "./app-optimistic-routing.js";
 import { removeStylesheetLinksCoveredByInlineCss } from "./app-inline-css-client.js";
 import { createElement, startTransition, use, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { flushSync } from "react-dom";
@@ -63,7 +63,9 @@ function toOperationLane(kind) {
 	}
 }
 const MAX_VISITED_RESPONSE_CACHE_SIZE = 50;
-const CLIENT_RSC_COMPATIBILITY_ID = getVinextRscCompatibilityId();
+const IS_STATIC_EXPORT = process.env.NODE_ENV === "production" && process.env.__NEXT_CONFIG_OUTPUT === "export";
+const CLIENT_DEPLOYMENT_VERSION = process.env.__VINEXT_BUILD_ID ?? null;
+const CLIENT_RSC_COMPATIBILITY_ID = IS_STATIC_EXPORT ? null : getVinextRscCompatibilityId();
 const optimisticRouteTemplates = /* @__PURE__ */ new Map();
 const optimisticRouteTemplateSources = /* @__PURE__ */ new Set();
 const optimisticRouteTemplateLearning = /* @__PURE__ */ new Map();
@@ -78,6 +80,20 @@ function markInitialAppRouterBootstrapHydrated() {
 function getBrowserRouteManifest() {
 	return getNavigationRuntime()?.bootstrap.routeManifest ?? null;
 }
+function resolveStaticExportRouteParams(href) {
+	const routeManifest = getBrowserRouteManifest();
+	if (routeManifest === null) return {};
+	return resolveOptimisticNavigationParamsForHref({
+		basePath: __basePath,
+		href,
+		routeManifest
+	}) ?? {};
+}
+function isStaticExportPayloadDeploymentCompatible(elements) {
+	if (!IS_STATIC_EXPORT) return true;
+	const deploymentVersion = AppElementsWire.readMetadata(elements).artifactCompatibility.deploymentVersion;
+	return CLIENT_DEPLOYMENT_VERSION !== null && deploymentVersion === CLIENT_DEPLOYMENT_VERSION;
+}
 const historyController = new AppBrowserHistoryController({
 	initialHistoryState: window.history.state,
 	maxHistoryStateSnapshots: 50,
@@ -214,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;
@@ -244,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;
@@ -381,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") {
@@ -423,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() {
@@ -696,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,
@@ -722,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;
@@ -730,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
 	});
@@ -809,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) {
@@ -829,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: {},
@@ -876,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();
@@ -919,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);
@@ -1118,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
 						});
@@ -1137,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({
@@ -1272,6 +1336,8 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 					}
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
 					const navContentType = navResponse.headers.get("content-type") ?? "";
+					const isNavigationRscContentType = navContentType.startsWith("text/x-component") || IS_STATIC_EXPORT && navContentType.startsWith("text/plain");
+					const navigationResponseUrl = IS_STATIC_EXPORT ? currentHref : navResponseUrl ?? navResponse.url;
 					const streamedRedirectTarget = navResponse.headers.get(VINEXT_RSC_REDIRECT_HEADER);
 					const streamedRedirectTypeHeader = navResponse.headers.get(VINEXT_RSC_REDIRECT_TYPE_HEADER);
 					const streamedRedirectType = streamedRedirectTypeHeader === "push" || streamedRedirectTypeHeader === "replace" ? streamedRedirectTypeHeader : null;
@@ -1282,12 +1348,12 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						currentHref,
 						effectiveHistoryUpdateMode: currentHistoryMode ?? "replace",
 						hasBody: navResponse.body !== null,
-						isRscContentType: navContentType.startsWith(VINEXT_RSC_CONTENT_TYPE),
+						isRscContentType: isNavigationRscContentType,
 						origin: window.location.origin,
 						redirectDepth: redirectCount,
 						requestPreviousNextUrl,
 						responseOk: navResponse.ok,
-						responseUrl: navResponseUrl ?? navResponse.url,
+						responseUrl: navigationResponseUrl,
 						source: "live",
 						streamedRedirectTarget,
 						streamedRedirectType
@@ -1309,8 +1375,8 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						continue;
 					}
 					if (!hasSupplementalRefresh) navigationAbortHandle.release();
-					const navParams = parseEncodedJsonHeader(navResponse.headers.get("X-Vinext-Params")) ?? {};
-					const navigationSnapshot = createClientNavigationRenderSnapshot(currentHref, navParams);
+					const navParams = parseEncodedJsonHeader(navResponse.headers.get("X-Vinext-Params")) ?? (IS_STATIC_EXPORT ? resolveStaticExportRouteParams(currentHref) : {});
+					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();
@@ -1343,6 +1409,15 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 							supplemental
 						}).then(requireCompleteSupplementalRefresh);
 					}
+					if (IS_STATIC_EXPORT) {
+						const staticExportElements = await rscPayload;
+						if (!browserNavigationController.isCurrentNavigation(navId)) return;
+						if (!isStaticExportPayloadDeploymentCompatible(staticExportElements)) {
+							performHardNavigationForScrollIntent(currentHref);
+							return;
+						}
+						rscPayload = Promise.resolve(staticExportElements);
+					}
 					if (!browserNavigationController.isCurrentNavigation(navId)) return;
 					let committedState = null;
 					if (await renderNavigationPayload({
@@ -1386,7 +1461,7 @@ function bootstrapHydration(rscStream, devErrorOverlay, initialRscBootstrap) {
 						if (navigationCacheGeneration !== clientNavigationCacheGeneration) return;
 						const metadata = AppElementsWire.readMetadata(renderedElements);
 						if (navigationCacheGeneration !== clientNavigationCacheGeneration) return;
-						const responseSnapshot = consumedPrefetchSnapshot ?? createCachedRscResponseSnapshot(navResponse, await cacheBufferPromise, navResponseUrl);
+						const responseSnapshot = consumedPrefetchSnapshot ?? createCachedRscResponseSnapshot(navResponse, await cacheBufferPromise, navigationResponseUrl);
 						const cacheRestorable = !(responseSnapshot.completedDynamicStaleTimeSeconds !== void 0) && isCacheRestorableAppPayloadMetadata(metadata);
 						const { completedDynamicStaleTimeSeconds: _staticCompletedDynamicStaleTime, dynamicStaleTimeSeconds: _staticDynamicStaleTime, ...staticResponseSnapshot } = responseSnapshot;
 						const snapshot = {
@@ -1493,10 +1568,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

@@ -9,23 +9,33 @@ 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__";
+export 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

@@ -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 { RSC_FORM_STATE_GLOBAL, 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