vinext 1.3.0 → 1.4.0

package/dist/shims/navigation.js

@@ -11,24 +11,24 @@ import { resolveDirectHybridClientRouteOwner } from "./internal/hybrid-client-ro
 import { isHashOnlyBrowserUrlChange, toCanonicalBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
 import { disableSmoothScrollDuringRouteTransition } from "./disable-smooth-scroll.js";
 import { retryScrollTo, scrollToHashTarget } from "./hash-scroll.js";
-import { AppElementsWire } from "../server/app-elements-wire.js";
-import "../server/app-elements.js";
-import { GLOBAL_ACCESSORS_KEY, ServerInsertedHTMLContext, _registerStateAccessors, clearClientHydrationContext, clearServerInsertedHTML, flushServerInsertedHTML, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext } from "./navigation-context-state.js";
-import { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, decodeRedirectError, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow } from "./navigation-errors.js";
-import { clearAppNavigationFailureTarget, stageAppNavigationFailureTarget } from "../client/app-nav-failure-handler.js";
-import { beginAppRouterScrollIntent, clearAppRouterScrollIntent, consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent, isLatestAppRouterScrollIntent } from "./app-router-scroll-state.js";
 import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, formatRscRequestPath, parseRscRequestPath, stripRscCacheBustingSearchParam, stripRscSuffix } from "../server/app-rsc-cache-busting.js";
+import { clearAppNavigationFailureTarget, stageAppNavigationFailureTarget } from "../client/app-nav-failure-handler.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import { getNavigationRuntime, hasAppNavigationRuntime, loadNavigationRuntimeRouteManifest } from "../client/navigation-runtime.js";
 import { UnrecognizedActionError, unstable_isUnrecognizedActionError } from "./unrecognized-action-error.js";
+import { AppElementsWire } from "../server/app-elements-wire.js";
+import "../server/app-elements.js";
 import { PUBLIC_INITIAL_BFCACHE_ID } from "../server/app-bfcache-id.js";
 import { resolveManifestNavigationInterceptionContext } from "../server/app-browser-interception-context.js";
-import { createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, isAppOwnedHistoryState } from "../server/app-history-state.js";
+import { createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, isAppOwnedHistoryState, readHistoryStateTraversalIndex } from "../server/app-history-state.js";
 import { hasPendingAppRouterPageRedirect } from "../server/app-browser-mpa-navigation.js";
 import { extractRscCompletionMetadata } from "../server/rsc-completion-metadata.js";
 import { navigationPlanner } from "../server/navigation-planner.js";
 import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
+import { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, decodeRedirectError, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow } from "./navigation-errors.js";
 import { getPagesNavigationContext } from "./internal/pages-router-accessor.js";
+import { beginAppRouterScrollIntent, clearAppRouterScrollIntent, consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent, isLatestAppRouterScrollIntent } from "./app-router-scroll-state.js";
+import { GLOBAL_ACCESSORS_KEY, ServerInsertedHTMLContext, _registerStateAccessors, clearClientHydrationContext, clearServerInsertedHTML, flushServerInsertedHTML, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext } from "./navigation-context-state.js";
 import { cancelAppPrefetchFetch, promoteAppPrefetchFetch, releaseAppPrefetchFetchSlot, scheduleAppPrefetchFetch } from "./internal/app-prefetch-fetch-queue.js";
 import * as React$1 from "react";
 //#region src/shims/navigation.ts
@@ -70,9 +70,9 @@ function useChildSegments(parallelRoutesKey = "children") {
 		return [];
 	}
 }
-const _READONLY_SEARCH_PARAMS = Symbol("vinext.navigation.readonlySearchParams");
-const _READONLY_SEARCH_PARAMS_SOURCE = Symbol("vinext.navigation.readonlySearchParamsSource");
-const _READONLY_SEARCH_PARAMS_SOURCE_KEY = Symbol("vinext.navigation.readonlySearchParamsSourceKey");
+const _READONLY_SEARCH_PARAMS = Symbol.for("vinext.navigation.readonlySearchParams");
+const _READONLY_SEARCH_PARAMS_SOURCE = Symbol.for("vinext.navigation.readonlySearchParamsSource");
+const _READONLY_SEARCH_PARAMS_SOURCE_KEY = Symbol.for("vinext.navigation.readonlySearchParamsSourceKey");
 const PAGES_NAVIGATION_NOTIFY_KEY = Symbol.for("vinext.navigation.pagesNavigationNotify");
 const isServer = typeof window === "undefined";
 /** basePath from next.config.js, injected by the plugin at build time */
@@ -296,9 +296,11 @@ function findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mounte
 function hasPrefetchCacheEntryForNavigation(rscUrl, interceptionContext = null, mountedSlotsHeader = null, options = {}) {
 	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, options.additionalRscUrls);
 	if (match === null) return false;
+	if (match.entry.pending !== void 0 && options.reusePending === false) return false;
 	if (match.entry.pending !== void 0 || resolvePrefetchCacheEntryExpiresAt(match.entry) > Date.now()) {
 		touchPrefetchCacheEntry(getPrefetchCache(), match.cacheKey, match.entry);
 		attachPrefetchInvalidationToEntry(match.cacheKey, match.entry, options.onInvalidate);
+		options.onReuse?.(match.entry, match.cacheKey);
 		return true;
 	}
 	deletePrefetchCacheEntry(getPrefetchCache(), getPrefetchedUrls(), match.cacheKey, match.entry, options.notifyInvalidation ?? true);
@@ -465,9 +467,13 @@ const retainedPrefetchInvalidations = /* @__PURE__ */ new Set();
 function retainPrefetchInvalidationAfterConsume(entry) {
 	const callbacks = entry.onInvalidateCallbacks;
 	if (callbacks === void 0 || callbacks.size === 0) return;
-	const delay = Math.max(0, resolvePrefetchCacheEntryExpiresAt(entry) - Date.now());
+	retainPrefetchInvalidation(callbacks, resolvePrefetchCacheEntryExpiresAt(entry));
+}
+function retainPrefetchInvalidation(callbacks, expiresAt, forVisitedResponse = false) {
+	const delay = Math.max(0, expiresAt - Date.now());
 	const retained = {
 		callbacks,
+		...forVisitedResponse ? { forVisitedResponse: true } : {},
 		timer: setTimeout(() => fireRetainedPrefetchInvalidation(retained), delay)
 	};
 	retainedPrefetchInvalidations.add(retained);
@@ -494,7 +500,7 @@ function deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, notify) {
 		entry.onInvalidateCallbacks = void 0;
 	}
 }
-function discardLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext = null) {
+function discardLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext = null, mountedSlotsHeader = null) {
 	const cache = getPrefetchCache();
 	const prefetched = getPrefetchedUrls();
 	const normalizedTarget = normalizeRscCacheLookupUrl(rscUrl);
@@ -505,6 +511,7 @@ function discardLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext = nul
 		const source = parsePrefetchCacheKey(cacheKey);
 		if (source.interceptionContext !== interceptionContext) continue;
 		if (normalizeRscCacheLookupUrl(source.rscUrl) !== normalizedTarget) continue;
+		if (!isPrefetchCacheEntryCompatibleWithMountedSlots(entry, mountedSlotsHeader)) continue;
 		superseded.push([cacheKey, entry]);
 	}
 	for (const [cacheKey, entry] of superseded) {
@@ -513,6 +520,25 @@ function discardLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext = nul
 	}
 	return superseded.length > 0;
 }
+/**
+* Make a prefetch reusable by a navigation, as an `unstable_dynamicOnHover`
+* hover does. A pending one that would be kept as learning-only becomes a full
+* prefetch and takes the full-prefetch lifetime. One already kept as
+* learning-only because its page rendered dynamically is left for the full
+* prefetch to replace: Next.js refetches it with `FetchStrategy.Full`, so the
+* page reflects the cookies and headers at hover time.
+*/
+function promotePrefetchCacheEntryForNavigation(cacheKey, entry) {
+	if (entry.dynamicStaleTime !== "learning-only") {
+		entry.cacheForNavigation = true;
+		return;
+	}
+	if (entry.cacheForNavigation === false) return;
+	entry.dynamicStaleTime = "full-prefetch";
+	if (entry.snapshot === void 0) return;
+	entry.expiresAt = resolvePrefetchedRscResponseExpiresAt(entry.timestamp, entry.snapshot, entry.fallbackTtlMs ?? PREFETCH_CACHE_TTL, "full-prefetch");
+	schedulePrefetchInvalidation(cacheKey, entry);
+}
 function invalidatePrefetchCacheEntry(cacheKey) {
 	const cache = getPrefetchCache();
 	const entry = cache.get(cacheKey);
@@ -548,14 +574,37 @@ function attachPrefetchInvalidationCallback(cacheKey, onInvalidate) {
 	if (!entry) return;
 	attachPrefetchInvalidationToEntry(cacheKey, entry, onInvalidate);
 }
-function invalidatePrefetchCache() {
+function invalidatePrefetchCache(options = {}) {
 	cancelPendingPrefetchSetups(null);
 	const cache = getPrefetchCache();
 	const prefetched = getPrefetchedUrls();
 	for (const [cacheKey, entry] of cache) deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, true);
 	prefetched.clear();
 	for (const retained of retainedPrefetchInvalidations) fireRetainedPrefetchInvalidation(retained);
-	if (!isServer) getNavigationRuntime()?.functions.pingVisibleLinks?.();
+	if (!isServer && options.pingVisibleLinks !== false) getNavigationRuntime()?.functions.pingVisibleLinks?.();
+}
+/**
+* Evict the prefetch entries that may hold dynamic data, for a Server Action
+* that called `refresh()`. Like Next.js's dynamic-only revalidation, which
+* evicts its BFCache but keeps its prefetch cache, this keeps route trees,
+* static prefetches and full prefetches. It drops navigation responses, and
+* automatic prefetches whose page rendered dynamically or hasn't finished
+* rendering, including those only kept to learn a route: Next.js's automatic
+* prefetches never hold dynamic data.
+*/
+function invalidateDynamicPrefetchCache() {
+	const cache = getPrefetchCache();
+	const prefetched = getPrefetchedUrls();
+	const evicted = [];
+	for (const [cacheKey, entry] of cache) if (!(entry.prefetchKind === "route-tree" || entry.prefetchKind !== void 0 && (entry.dynamicStaleTime === "full-prefetch" || entry.snapshot !== void 0 && !isStaleTimeSeconds(entry.snapshot.dynamicStaleTimeSeconds)))) evicted.push([cacheKey, entry]);
+	for (const [cacheKey, entry] of evicted) deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, true);
+}
+/**
+* Notify the prefetches that stood in for a visited response (see
+* `hasNavigationFreshVisitedResponse`), as the visited responses are cleared.
+*/
+function invalidateVisitedResponsePrefetches() {
+	for (const retained of retainedPrefetchInvalidations) if (retained.forVisitedResponse === true) fireRetainedPrefetchInvalidation(retained);
 }
 /**
 * Prevent completed navigation responses from becoming authoritative again
@@ -571,7 +620,7 @@ function disableNavigationResponsePrefetchCacheReuse() {
 	}
 	if (didDemote && !isServer) getNavigationRuntime()?.functions.pingVisibleLinks?.();
 }
-function seedPrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext = null, mountedSlotsHeader = null, fallbackTtlMs = DYNAMIC_NAVIGATION_CACHE_TTL, reuseAfterHistoryRestore = false) {
+function seedPrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext = null, mountedSlotsHeader = null, fallbackTtlMs = DYNAMIC_NAVIGATION_CACHE_TTL, reuseAfterHistoryRestore = false, expiresAt = resolveCachedRscResponseExpiresAt(Date.now(), snapshot, fallbackTtlMs)) {
 	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 	const cache = getPrefetchCache();
 	const existing = cache.get(cacheKey);
@@ -580,7 +629,7 @@ function seedPrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext = nu
 	const entry = {
 		cacheForNavigation: true,
 		cacheKeys: /* @__PURE__ */ new Set([cacheKey]),
-		expiresAt: resolveCachedRscResponseExpiresAt(timestamp, snapshot, fallbackTtlMs),
+		expiresAt,
 		mountedSlotsHeader,
 		outcome: "cache-seeded",
 		reuseAfterHistoryRestore,
@@ -594,6 +643,35 @@ function seedPrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext = nu
 	schedulePrefetchInvalidation(cacheKey, entry);
 	evictPrefetchCacheIfNeeded();
 }
+/**
+* Fulfill a full prefetch from the visited response of an earlier navigation,
+* as Next.js does from its BFCache, instead of issuing a request. The data is
+* fresh for the static stale time from the navigation, not the dynamic one
+* (`attemptToFulfillDynamicSegmentFromBFCache`).
+*/
+function seedFullPrefetchFromVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, additionalRscUrls = [], onInvalidate) {
+	const visited = getNavigationRuntime()?.functions.readVisitedResponseForFullPrefetch?.([rscUrl, ...additionalRscUrls], interceptionContext, mountedSlotsHeader);
+	if (!visited) return false;
+	const expiresAt = visited.navigatedAt + Math.max(PREFETCH_CACHE_TTL, MIN_PREFETCH_STALE_TIME_MS);
+	if (expiresAt <= Date.now()) return false;
+	seedPrefetchResponseSnapshot(rscUrl, visited.response, interceptionContext, mountedSlotsHeader, void 0, true, expiresAt);
+	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
+	if (getPrefetchCache().get(cacheKey)?.snapshot !== visited.response) return false;
+	attachPrefetchInvalidationCallback(cacheKey, onInvalidate);
+	return true;
+}
+/**
+* Whether a navigation to the URL would reuse the response of an earlier one,
+* so a prefetch has nothing to fetch. Like Next.js, whose navigation keeps the
+* route and its segments for `staleTimes.dynamic`. `onInvalidate` fires when
+* that reuse ends.
+*/
+function hasNavigationFreshVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, additionalRscUrls = [], onInvalidate) {
+	const freshUntil = getNavigationRuntime()?.functions.readVisitedResponseForFullPrefetch?.([rscUrl, ...additionalRscUrls], interceptionContext, mountedSlotsHeader)?.navigationFreshUntil;
+	if (freshUntil === void 0 || freshUntil === null) return false;
+	if (onInvalidate !== void 0) retainPrefetchInvalidation(/* @__PURE__ */ new Set([onInvalidate]), freshUntil, true);
+	return true;
+}
 function deletePrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext = null) {
 	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 	const cache = getPrefetchCache();
@@ -672,6 +750,7 @@ function createCachedRscResponseSnapshot(response, buffer, responseUrl = null) {
 		...dynamicStaleTimeSeconds !== void 0 ? { dynamicStaleTimeSeconds } : {},
 		mountedSlotsHeader: response.headers.get(VINEXT_MOUNTED_SLOTS_HEADER),
 		paramsHeader: response.headers.get(VINEXT_PARAMS_HEADER),
+		receivedAt: Date.now(),
 		...redirectHeader === null ? {} : { redirectHeader },
 		...redirectTypeHeader === null ? {} : { redirectTypeHeader },
 		renderedPathAndSearch: parseRenderedPathAndSearchHeader(response.headers.get(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER)),
@@ -837,6 +916,10 @@ function prefetchRscResponse(rscUrl, fetchPromise, interceptionContext = null, m
 		searchAgnosticShell: behavior.searchAgnosticShell === true,
 		timestamp: now
 	};
+	if (behavior.dynamicStaleTime === "learning-only" && behavior.searchAgnosticShell !== true) {
+		entry.dynamicStaleTime = "learning-only";
+		entry.fallbackTtlMs = behavior.fallbackTtlMs ?? PREFETCH_CACHE_TTL;
+	} else if (behavior.dynamicStaleTime === "full-prefetch") entry.dynamicStaleTime = "full-prefetch";
 	addPrefetchInvalidationCallback(entry, options?.onInvalidate);
 	entry.fetchPromise = fetchPromise;
 	entry.pending = fetchPromise.then(async (response) => {
@@ -847,8 +930,13 @@ function prefetchRscResponse(rscUrl, fetchPromise, interceptionContext = null, m
 			entry.snapshot = snapshot;
 			entry.size = snapshot.buffer.byteLength;
 			adjustPrefetchCacheByteSize(cache, entry.size - previousSize);
-			entry.expiresAt = resolvePrefetchedRscResponseExpiresAt(entry.timestamp, entry.snapshot, behavior.fallbackTtlMs ?? PREFETCH_CACHE_TTL, behavior.searchAgnosticShell === true ? "ignore" : behavior.dynamicStaleTime ?? (behavior.optimisticRouteShell === true ? "ignore" : "verbatim"));
-			if (behavior.prepareSnapshot && snapshot.redirectHeader === void 0) try {
+			const fallbackTtlMs = behavior.fallbackTtlMs ?? PREFETCH_CACHE_TTL;
+			const dynamicStaleTime = behavior.searchAgnosticShell === true ? "ignore" : entry.dynamicStaleTime ?? behavior.dynamicStaleTime ?? (behavior.optimisticRouteShell === true ? "ignore" : "verbatim");
+			if (dynamicStaleTime === "learning-only" && isStaleTimeSeconds(snapshot.dynamicStaleTimeSeconds)) {
+				entry.cacheForNavigation = false;
+				entry.expiresAt = entry.timestamp + Math.max(fallbackTtlMs, MIN_PREFETCH_STALE_TIME_MS);
+			} else entry.expiresAt = resolvePrefetchedRscResponseExpiresAt(entry.timestamp, entry.snapshot, fallbackTtlMs, dynamicStaleTime === "learning-only" ? "verbatim" : dynamicStaleTime);
+			if (behavior.prepareSnapshot && entry.cacheForNavigation && snapshot.redirectHeader === void 0) try {
 				const preparedElements = await behavior.prepareSnapshot(snapshot);
 				if (cache.get(cacheKey) !== entry) return;
 				entry.preparedElements = preparedElements;
@@ -952,8 +1040,12 @@ async function consumePrefetchResponseForNavigation(rscUrl, interceptionContext
 	if (options?.shouldConsume?.() === false) return null;
 	const allowExpiredInFlightHandoff = entry.pending !== void 0;
 	if (entry.pending !== void 0) {
-		promoteAppPrefetchFetch(entry.fetchPromise);
-		await entry.pending.catch(() => {});
+		const releaseClaim = promoteAppPrefetchFetch(entry.fetchPromise, options?.shouldConsume);
+		try {
+			await entry.pending.catch(() => {});
+		} finally {
+			releaseClaim();
+		}
 		if (cache.get(cacheKey) !== entry) return null;
 		if (options?.shouldConsume?.() === false) return null;
 	}
@@ -987,6 +1079,8 @@ function getClientNavigationState() {
 		originalPushState: window.history.pushState.bind(window.history),
 		originalReplaceState: window.history.replaceState.bind(window.history),
 		patchInstalled: false,
+		routerHistoryWriteDepth: 0,
+		routerHistoryWrite: null,
 		hasPendingNavigationUpdate: false,
 		suppressUrlNotifyCount: 0,
 		navigationSnapshotActiveCount: 0
@@ -1040,14 +1134,31 @@ let _cachedEmptyClientSearchParams = null;
 * be visible until the next commit.
 */
 function getSearchParamsSnapshot() {
-	if (getNavigationContext()) return getServerSearchParamsSnapshot();
+	const hasAppContext = getNavigationContext() !== null;
 	const pagesCtx = getPagesNavigationContext();
-	if (pagesCtx) return getReadonlyPagesSearchParams(pagesCtx.searchParams);
-	const cached = getClientNavigationState()?.cachedReadonlySearchParams;
-	if (cached) return cached;
+	if (!hasAppContext && pagesCtx) return getReadonlyPagesSearchParams(pagesCtx.searchParams);
+	const state = getClientNavigationState();
+	if (state) {
+		if (hasAppContext) adoptHydrationSearchParams(state);
+		return state.cachedReadonlySearchParams;
+	}
 	if (_cachedEmptyClientSearchParams === null) _cachedEmptyClientSearchParams = new ReadonlyURLSearchParams();
 	return _cachedEmptyClientSearchParams;
 }
+let _comparedHydrationSearchParams = null;
+/**
+* Keep the hydrated search params object when the browser URL has the same
+* query. React compares the two snapshots by identity once hydrated, so a new
+* object would re-render every useSearchParams() caller and re-run effects
+* keyed on it, where Next.js keeps one object from the first render.
+*/
+function adoptHydrationSearchParams(state) {
+	const hydrated = getServerSearchParamsSnapshot();
+	if (hydrated === state.cachedReadonlySearchParams) return;
+	if (hydrated === _comparedHydrationSearchParams) return;
+	_comparedHydrationSearchParams = hydrated;
+	if (hydrated.toString() === state.cachedReadonlySearchParams.toString()) state.cachedReadonlySearchParams = hydrated;
+}
 function syncCommittedUrlStateFromLocation() {
 	const state = getClientNavigationState();
 	if (!state) return false;
@@ -1313,16 +1424,80 @@ function commitClientNavigationState(navId, options) {
 	if (urlChanged || paramsChanged) clearClientHydrationContext();
 	if (shouldNotify) notifyNavigationListeners();
 }
-function pushHistoryStateWithoutNotify(data, unused, url) {
-	withSuppressedUrlNotifications(() => {
-		getClientNavigationState()?.originalPushState.call(window.history, data, unused, url);
-	});
+/** Whether a history entry's state is the data written to it, cloned by the browser. */
+function isSameHistoryStateData(historyState, data) {
+	try {
+		return JSON.stringify(historyState) === JSON.stringify(data);
+	} catch {
+		return false;
+	}
 }
-function replaceHistoryStateWithoutNotify(data, unused, url) {
+/** Writes the in-progress router write if this call is it, consuming its marker. */
+function forwardRouterHistoryWrite(state, method, data, unused, url) {
+	const write = state.routerHistoryWrite;
+	if (write?.method !== method) return false;
+	if (write.threw) {
+		if (url == null || new URL(url, window.location.href).href !== write.href) return false;
+		if (write.data !== data && !(isAppOwnedHistoryState(data) && readHistoryStateTraversalIndex(data) === readHistoryStateTraversalIndex(write.data))) return false;
+	} else if (write.data !== data || write.url !== url) return false;
+	if (write.landed) return true;
+	state.routerHistoryWrite = null;
+	const landing = write.land?.(data);
+	const original = method === "pushState" ? state.originalPushState : state.originalReplaceState;
+	const writtenData = landing ? landing.data : data;
+	const historyStateBeforeWrite = window.history.state;
+	try {
+		original.call(window.history, writtenData, unused, url);
+	} catch (error) {
+		const landed = window.history.state !== historyStateBeforeWrite && window.location.href === write.href && isSameHistoryStateData(window.history.state, writtenData);
+		if (landed) landing?.commit();
+		state.routerHistoryWrite = {
+			...write,
+			threw: true,
+			landed
+		};
+		throw error;
+	}
+	landing?.commit();
+	if (write.threw) state.routerHistoryWrite = {
+		...write,
+		landed: true
+	};
+	return true;
+}
+function writeRouterHistoryState(method, data, unused, url, land) {
 	withSuppressedUrlNotifications(() => {
-		getClientNavigationState()?.originalReplaceState.call(window.history, data, unused, url);
+		const state = getClientNavigationState();
+		if (!state) return;
+		if (url == null) {
+			(method === "pushState" ? state.originalPushState : state.originalReplaceState).call(window.history, data, unused, url);
+			return;
+		}
+		const previousWrite = state.routerHistoryWrite;
+		state.routerHistoryWriteDepth += 1;
+		state.routerHistoryWrite = {
+			method,
+			data,
+			url,
+			href: new URL(url, window.location.href).href,
+			land,
+			threw: false,
+			landed: false
+		};
+		try {
+			window.history[method](data, unused, url);
+		} finally {
+			state.routerHistoryWriteDepth -= 1;
+			state.routerHistoryWrite = previousWrite;
+		}
 	});
 }
+function pushHistoryStateWithoutNotify(data, unused, url, land) {
+	writeRouterHistoryState("pushState", data, unused, url, land);
+}
+function replaceHistoryStateWithoutNotify(data, unused, url, land) {
+	writeRouterHistoryState("replaceState", data, unused, url, land);
+}
 /**
 * Save the current scroll position into the current history state.
 * Called before every navigation to enable scroll restoration on back/forward.
@@ -1538,6 +1713,32 @@ function hasScheduledAppRouterNavigation() {
 function releaseScheduledAppRouterNavigationAfterCurrentTask(release) {
 	queueMicrotask(release);
 }
+let inFlightAppRouterNavigationCount = 0;
+let visibleLinkPingAwaitsNavigations = false;
+/**
+* Called by the App Router browser entry for each RSC navigation it runs.
+* Returns a release callback for the navigation's settlement.
+*/
+function trackAppRouterNavigationInFlight() {
+	inFlightAppRouterNavigationCount += 1;
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		inFlightAppRouterNavigationCount = Math.max(0, inFlightAppRouterNavigationCount - 1);
+		if (inFlightAppRouterNavigationCount === 0 && visibleLinkPingAwaitsNavigations) {
+			visibleLinkPingAwaitsNavigations = false;
+			getNavigationRuntime()?.functions.pingVisibleLinks?.();
+		}
+	};
+}
+function pingVisibleLinksOnceNavigationsSettle() {
+	if (inFlightAppRouterNavigationCount > 0) {
+		visibleLinkPingAwaitsNavigations = true;
+		return;
+	}
+	getNavigationRuntime()?.functions.pingVisibleLinks?.();
+}
 /**
 * App Router public router instance. Mirrors Next.js's
 * `publicAppRouterInstance` from
@@ -1589,15 +1790,16 @@ const _appRouter = {
 	},
 	refresh() {
 		if (isServer) return;
-		getNavigationRuntime()?.functions.clearNavigationCaches?.();
-		if (hasScheduledAppRouterNavigation()) return;
+		getNavigationRuntime()?.functions.clearNavigationCaches?.({ pingVisibleLinks: false });
 		const rscNavigate = getNavigationRuntime()?.functions.navigate;
-		if (rscNavigate) {
-			const navigate = () => {
-				rscNavigate(window.location.href, 0, "refresh", void 0, void 0, true);
-			};
-			React$1.startTransition(navigate);
+		if (hasScheduledAppRouterNavigation() || !rscNavigate) {
+			getNavigationRuntime()?.functions.pingVisibleLinks?.();
+			return;
 		}
+		const navigate = () => {
+			rscNavigate(window.location.href, 0, "refresh", void 0, void 0, true).finally(pingVisibleLinksOnceNavigationsSettle);
+		};
+		React$1.startTransition(navigate);
 	},
 	prefetch(href, options) {
 		assertSafeNavigationUrl(href);
@@ -1635,7 +1837,7 @@ const _appRouter = {
 			const kind = options?.kind === "full" ? "full" : "auto";
 			const [{ resolveAutoAppRoutePrefetch, resolveFullAppRoutePrefetch }, { resolveAppPrefetchRscRequest }] = await Promise.all([import("./internal/app-route-prefetch-policy.js"), import("./internal/app-prefetch-rsc-request.js")]);
 			if (setup.cancelled) return;
-			const policy = kind === "full" ? resolveFullAppRoutePrefetch() : resolveAutoAppRoutePrefetch(rewrittenPrefetchHref ?? fullHref);
+			const policy = kind === "full" ? resolveFullAppRoutePrefetch() : resolveAutoAppRoutePrefetch(rewrittenPrefetchHref ?? fullHref, interceptionContext);
 			const reusable = policy.shouldPrefetch && policy.cacheForNavigation;
 			const requiresRouteTreePrefetch = policy.requiresRouteTreePrefetch === true;
 			if (reusable && kind === "full") headers.delete(NEXT_ROUTER_PREFETCH_HEADER);
@@ -1647,7 +1849,7 @@ const _appRouter = {
 			if (!reusable && kind === "auto") {
 				headers.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
 				headers.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, "1");
-				headers.set(VINEXT_RSC_RENDER_MODE_HEADER, hasSearchParams ? APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL : APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL);
+				headers.set(VINEXT_RSC_RENDER_MODE_HEADER, hasSearchParams && policy.rendersDynamically !== true ? APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL : APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL);
 			}
 			const { additionalRscUrls, rscUrl } = await resolveAppPrefetchRscRequest({
 				fullHref,
@@ -1657,16 +1859,20 @@ const _appRouter = {
 			if (setup.cancelled) return;
 			const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 			const prefetched = getPrefetchedUrls();
+			if (policy.dynamicStaleTime !== "full-prefetch" && hasFreshLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext)) {
+				attachPrefetchInvalidationCallback(cacheKey, options?.onInvalidate);
+				return;
+			}
 			if (reusable) {
-				discardLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext);
+				discardLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext, mountedSlotsHeader);
 				if (hasPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, {
 					additionalRscUrls,
-					onInvalidate: options?.onInvalidate
+					onInvalidate: options?.onInvalidate,
+					onReuse: policy.dynamicStaleTime === "full-prefetch" ? (entry, matchedCacheKey) => promotePrefetchCacheEntryForNavigation(matchedCacheKey, entry) : void 0
 				})) return;
-			} else if (hasFreshLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext)) {
-				attachPrefetchInvalidationCallback(cacheKey, options?.onInvalidate);
-				return;
+				if (policy.dynamicStaleTime === "full-prefetch" && seedFullPrefetchFromVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, additionalRscUrls, options?.onInvalidate)) return;
 			}
+			if (policy.dynamicStaleTime !== "full-prefetch" && hasNavigationFreshVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, additionalRscUrls, options?.onInvalidate)) return;
 			prefetched.add(cacheKey);
 			const fetchFullRscPayload = () => scheduleAppPrefetchFetch((signal) => fetch(rscUrl, {
 				headers,
@@ -1824,7 +2030,8 @@ if (!isServer) {
 			}
 		});
 		window.history.pushState = function patchedPushState(data, unused, url) {
-			getNavigationRuntime()?.functions.flushCommittingNavigationUrl?.();
+			if (forwardRouterHistoryWrite(state, "pushState", data, unused, url)) return;
+			if (state.routerHistoryWriteDepth === 0) getNavigationRuntime()?.functions.flushCommittingNavigationUrl?.();
 			if (isAppOwnedHistoryState(data)) {
 				const previousHistoryState = window.history.state;
 				state.originalPushState.call(window.history, data, unused, url);
@@ -1841,7 +2048,8 @@ if (!isServer) {
 			}
 		};
 		window.history.replaceState = function patchedReplaceState(data, unused, url) {
-			getNavigationRuntime()?.functions.flushCommittingNavigationUrl?.();
+			if (forwardRouterHistoryWrite(state, "replaceState", data, unused, url)) return;
+			if (state.routerHistoryWriteDepth === 0) getNavigationRuntime()?.functions.flushCommittingNavigationUrl?.();
 			if (isAppOwnedHistoryState(data)) {
 				const previousHistoryState = window.history.state;
 				state.originalReplaceState.call(window.history, data, unused, url);
@@ -1860,4 +2068,4 @@ if (!isServer) {
 	}
 }
 //#endregion
-export { BailoutToCSRError, DYNAMIC_NAVIGATION_CACHE_TTL, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, MAX_PREFETCH_CACHE_SIZE, PREFETCH_CACHE_TTL, ReadonlyURLSearchParams, RedirectType, ServerInsertedHTMLContext, UnrecognizedActionError, __basePath, _registerStateAccessors, activateNavigationSnapshot, appRouterInstance, applyAppRouterScrollFallback, clearPendingPathname, clearServerInsertedHTML, commitClientNavigationState, consumePrefetchResponse, consumePrefetchResponseForNavigation, createAppPrefetchRequestHeaders, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, decodeRedirectError, deletePrefetchResponseSnapshot, disableNavigationResponsePrefetchCacheReuse, discardLearningOnlyPrefetchCacheEntry, fetchRouteTreeGatedPrefetch, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getClientNavigationRenderContext, getClientNavigationState, getClientParams, getCurrentInterceptionContext, getCurrentNextUrl, getFreshPrefetchCacheEntry, getLayoutSegmentContext, getMountedSlotsHeader, getNavigationContext, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, hasFreshLearningOnlyPrefetchCacheEntry, hasPrefetchCacheEntryForNavigation, hasSearchAgnosticPrefetchShellForRoute, invalidatePrefetchCache, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, navigateClientSide, notFound, parseRenderedPathAndSearchHeader, peekPrefetchResponseForNavigation, permanentRedirect, prefetchRscResponse, preloadHybridClientRouteOwner, prepareNavigationPrefetchSnapshot, pushHistoryStateWithoutNotify, redirect, renderServerInsertedHTML, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveCachedRscResponseExpiresAt, resolveCachedRscResponseTtlMs, resolveLoadedHybridClientRewriteHref, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, seedPrefetchResponseSnapshot, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname, snapshotRscResponse, storePrefetchResponse, unauthorized, unstable_isUnrecognizedActionError, unstable_rethrow, useClientNavigationRenderSnapshot, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };
+export { BailoutToCSRError, DYNAMIC_NAVIGATION_CACHE_TTL, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, MAX_PREFETCH_CACHE_SIZE, PREFETCH_CACHE_TTL, ReadonlyURLSearchParams, RedirectType, ServerInsertedHTMLContext, UnrecognizedActionError, __basePath, _registerStateAccessors, activateNavigationSnapshot, appRouterInstance, applyAppRouterScrollFallback, clearPendingPathname, clearServerInsertedHTML, commitClientNavigationState, consumePrefetchResponse, consumePrefetchResponseForNavigation, createAppPrefetchRequestHeaders, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, decodeRedirectError, deletePrefetchResponseSnapshot, disableNavigationResponsePrefetchCacheReuse, discardLearningOnlyPrefetchCacheEntry, fetchRouteTreeGatedPrefetch, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getClientNavigationRenderContext, getClientNavigationState, getClientParams, getCurrentInterceptionContext, getCurrentNextUrl, getFreshPrefetchCacheEntry, getLayoutSegmentContext, getMountedSlotsHeader, getNavigationContext, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, hasFreshLearningOnlyPrefetchCacheEntry, hasNavigationFreshVisitedResponse, hasPrefetchCacheEntryForNavigation, hasSearchAgnosticPrefetchShellForRoute, invalidateDynamicPrefetchCache, invalidatePrefetchCache, invalidateVisitedResponsePrefetches, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, navigateClientSide, notFound, parseRenderedPathAndSearchHeader, peekPrefetchResponseForNavigation, permanentRedirect, prefetchRscResponse, preloadHybridClientRouteOwner, prepareNavigationPrefetchSnapshot, promotePrefetchCacheEntryForNavigation, pushHistoryStateWithoutNotify, redirect, renderServerInsertedHTML, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveCachedRscResponseExpiresAt, resolveCachedRscResponseTtlMs, resolveLoadedHybridClientRewriteHref, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, seedFullPrefetchFromVisitedResponse, seedPrefetchResponseSnapshot, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname, snapshotRscResponse, storePrefetchResponse, trackAppRouterNavigationInFlight, unauthorized, unstable_isUnrecognizedActionError, unstable_rethrow, useClientNavigationRenderSnapshot, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };

package/dist/shims/navigation.react-server.js

@@ -1,7 +1,7 @@
-import { GLOBAL_ACCESSORS_KEY, ServerInsertedHTMLContext, _registerStateAccessors, clearServerInsertedHTML, flushServerInsertedHTML, getLayoutSegmentContext, getNavigationContext, renderServerInsertedHTML, setNavigationContext } from "./navigation-context-state.js";
+import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
 import { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow } from "./navigation-errors.js";
+import { GLOBAL_ACCESSORS_KEY, ServerInsertedHTMLContext, _registerStateAccessors, clearServerInsertedHTML, flushServerInsertedHTML, getLayoutSegmentContext, getNavigationContext, renderServerInsertedHTML, setNavigationContext } from "./navigation-context-state.js";
 import "./navigation-server.js";
-import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
 import { throwClientHookError } from "./client-hook-error.js";
 //#region src/shims/navigation.react-server.ts
 function usePathname() {

package/dist/shims/pages-router-runtime.d.ts

@@ -8,4 +8,5 @@ export declare function setPagesRouterPopStateHandler(handler: PagesRouterPopSta
  */
 export declare function setStampInitialHistoryState(fn: () => void): void;
 export declare function installPagesRouterRuntime(): void;
-//#endregion
+//#endregion
+export {};

package/dist/shims/ppr-fallback-shell.d.ts

@@ -29,4 +29,5 @@ export declare function waitForPprFallbackShellCacheReady(state: PprFallbackShel
 export declare function preparePprFallbackShellFinalRender(state: PprFallbackShellState): void;
 export declare function beginPprFallbackShellFinalRender(state: PprFallbackShellState): void;
 export declare function isPprFallbackShellAbortError(error: unknown): boolean;
-//#endregion
+//#endregion
+export {};

package/dist/shims/request-state-types.d.ts

@@ -1,12 +1,12 @@
-import { ExecutionContextLike } from "./request-context.js";
 import { NavigationContext } from "./navigation-context-state.js";
 import "./navigation.js";
-import { CacheLifeConfig, CacheState } from "./cache-request-state.js";
+import { ExecutionContextLike } from "./request-context.js";
 import { RootParamsState } from "./root-params.js";
 import { FetchCacheState } from "./fetch-cache-state.js";
 import "./fetch-cache.js";
 import { HeadersAccessPhase, VinextHeadersShimState } from "./internal/headers-state.js";
 import { HeadersContext } from "./headers.js";
+import { CacheLifeConfig, CacheState } from "./cache-request-state.js";
 import { RouterState, SSRContext } from "./router-state.js";
 import { PrivateCacheState } from "./cache-runtime.js";
 import { HeadState } from "./head-state.js";

package/dist/shims/router.js

@@ -1006,15 +1006,26 @@ function getClientConfigRouteContext(href) {
 		search: parsed.search
 	};
 }
+/**
+* matchRedirect has already applied basePath to a config destination, so a
+* local one that resolves outside it (`/../outside`, or a `basePath: false`
+* rule) is another app's URL. resolveLocalRedirectUrl would treat it as an app
+* path and re-add basePath, so it is followed as a document navigation instead,
+* landing where the server's redirect does.
+*/
+function configRedirectLeavesBasePath(location) {
+	if (!__basePath || !location.startsWith("/") || location.startsWith("//")) return false;
+	return !hasBasePath(new URL(location, "http://vinext.local").pathname, __basePath);
+}
 async function resolveClientConfigRedirect(href) {
 	const redirects = window.__VINEXT_CLIENT_REDIRECTS__;
 	if (!redirects || redirects.length === 0) return null;
 	const routeContext = getClientConfigRouteContext(href);
 	if (!routeContext) return null;
-	const [{ matchClientRedirect }, { preserveRedirectDestinationQuery }] = await Promise.all([import("../client/client-redirect-matcher.js"), import("../config/config-matchers.js")]);
+	const [{ matchClientRedirect }, { encodeRedirectLocation, preserveRedirectDestinationQuery }] = await Promise.all([import("../client/client-redirect-matcher.js"), import("../config/config-matchers.js")]);
 	const redirect = matchClientRedirect(routeContext.pathname, redirects, routeContext.context, routeContext.basePathState);
 	if (!redirect) return null;
-	return preserveRedirectDestinationQuery(__basePath && routeContext.basePathState.hadBasePath && !isExternalUrl(redirect.destination) && !hasBasePath(redirect.destination, __basePath) ? __basePath + redirect.destination : redirect.destination, routeContext.search, redirect.destinationQuery);
+	return encodeRedirectLocation(preserveRedirectDestinationQuery(redirect.destination, routeContext.search, redirect.destinationQuery));
 }
 async function applyClientConfigRewrite(href, rewrite) {
 	const routeContext = getClientConfigRouteContext(href);
@@ -1569,7 +1580,7 @@ async function navigateClient(url, fetchUrl = url, options = {}, routeUrl = url)
 			const routeMasked = options.routeMasked ?? routeUrl !== url;
 			const configRedirect = hasClientRedirectRules() && clientConfigRedirectCouldMatch(browserUrl) ? await resolveClientConfigRedirect(browserUrl) : null;
 			if (configRedirect) {
-				const redirectedUrl = resolveLocalRedirectUrl(configRedirect);
+				const redirectedUrl = configRedirectLeavesBasePath(configRedirect) ? null : resolveLocalRedirectUrl(configRedirect);
 				if (!redirectedUrl) scheduleHardNavigationAndThrow(configRedirect, "Navigation redirected externally");
 				throw new InternalNavigationRedirect(redirectedUrl);
 			}

package/dist/shims/slot.d.ts

@@ -59,6 +59,18 @@ export declare function BfcacheSegmentBoundary({ children, id, stateKey }: {
   id: string;
   stateKey: string;
 }): React$1.JSX.Element;
+/**
+ * Retains a layout's children across navigations that change which segment
+ * they render. Each child keeps its own wrappers, so a page and a nested layout
+ * give the layout's children different element shapes, and a retention list
+ * inside the child would remount with them. Next.js keeps this Activity list in
+ * the parent's layout router, above the child's boundaries, so a page left for a
+ * sibling with its own layout keeps its state when navigating back.
+ */
+export declare function BfcacheChildrenBoundary({ children, id }: {
+  children: React$1.ReactNode;
+  id: string;
+}): React$1.JSX.Element;
 export declare function getNonCacheComponentsSegmentKey(id: string, activeStateKey: string): string | undefined;
 export declare function resolveBfcacheSegmentStateKey(id: string, identityMap: Readonly<Record<string, string>>, bfcacheIdMap: Readonly<Record<string, string>> | null): string | undefined;
 export declare function mergeElements(prev: AppElements, next: AppElements, options?: MergeElementsOptions | boolean): AppElements;