vinext 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/shims/navigation.js

@@ -1,5 +1,5 @@
 import { stripBasePath } from "../utils/base-path.js";
-import { VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER } from "../server/headers.js";
+import { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STALE_TIME_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_RSC_COMPLETION_METADATA_HEADER, VINEXT_STALE_TIME_PENDING_HEADER } from "../server/headers.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
 import { isExternalUrl } from "../utils/external-url.js";
 import { AppElementsWire } from "../server/app-elements-wire.js";
@@ -7,24 +7,25 @@ import "../server/app-elements.js";
 import { markPprFallbackShellDynamicBoundary } from "./ppr-fallback-shell.js";
 import { AppRouterContext } from "./internal/app-router-context.js";
 import { resolveDirectHybridClientRouteOwner } from "./internal/hybrid-client-route-owner-direct.js";
-import { toBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
-import { retryScrollTo, scrollToHashTarget } from "./hash-scroll.js";
+import { isHashOnlyBrowserUrlChange, toBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
+import { retryScrollTo, scrollToHashTarget, scrollToHashTargetOnNextFrame } from "./hash-scroll.js";
 import { isBotUserAgent } from "../utils/html-limited-bots.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 } from "./app-router-scroll-state.js";
+import { beginAppRouterScrollIntent, clearAppRouterScrollIntent, consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent, isLatestAppRouterScrollIntent } from "./app-router-scroll-state.js";
 import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createRscRequestHeaders, createRscRequestUrl, stripRscCacheBustingSearchParam, stripRscSuffix } from "../server/app-rsc-cache-busting.js";
 import { getNavigationRuntime, hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import { PUBLIC_INITIAL_BFCACHE_ID } from "../server/app-bfcache-id.js";
-import { resolveManifestNavigationInterceptionContext } from "../server/app-browser-interception-context.js";
 import { createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata } from "../server/app-history-state.js";
+import { resolveManifestNavigationInterceptionContext } from "../server/app-browser-interception-context.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 { getPagesNavigationContext } from "./internal/pages-router-accessor.js";
-import { releaseAppPrefetchFetchSlot, scheduleAppPrefetchFetch } from "./internal/app-prefetch-fetch-queue.js";
+import { cancelAppPrefetchFetch, promoteAppPrefetchFetch, releaseAppPrefetchFetchSlot, scheduleAppPrefetchFetch } from "./internal/app-prefetch-fetch-queue.js";
 import { UnrecognizedActionError, unstable_isUnrecognizedActionError } from "./unrecognized-action-error.js";
 import * as React$1 from "react";
 //#region src/shims/navigation.ts
@@ -36,6 +37,7 @@ import * as React$1 from "react";
 * Client-side: reads from browser Location API and provides navigation.
 */
 const HAS_PAGES_ROUTER = process.env.__VINEXT_HAS_PAGES_ROUTER !== "false";
+const HAS_CLIENT_REWRITES = process.env.__VINEXT_HAS_CLIENT_REWRITES !== "false";
 let hybridClientRouteOwnerModule = null;
 let hybridClientRouteOwnerModulePromise = null;
 /** Load rewrite-aware hybrid route ownership before navigation becomes interactive. */
@@ -72,6 +74,8 @@ const PAGES_NAVIGATION_NOTIFY_KEY = Symbol.for("vinext.navigation.pagesNavigatio
 const isServer = typeof window === "undefined";
 /** basePath from next.config.js, injected by the plugin at build time */
 const __basePath = process.env.__NEXT_ROUTER_BASEPATH ?? "";
+/** prefetch inlining (Segment Cache wire mode), injected by the plugin at build time */
+const __prefetchInlining = process.env.__VINEXT_PREFETCH_INLINING === "true";
 /** Maximum buffered bytes in the RSC prefetch cache. Mirrors Next.js' 50 MB LRU. */
 const MAX_PREFETCH_CACHE_SIZE = 50 * 1024 * 1024;
 const PREFETCH_CACHE_EVICTION_TARGET_SIZE = MAX_PREFETCH_CACHE_SIZE * .9;
@@ -97,7 +101,13 @@ function resolveClientRouterStaleTime(raw, fallbackMs) {
 }
 const DYNAMIC_NAVIGATION_CACHE_TTL = resolveClientRouterStaleTime(process.env.__NEXT_CLIENT_ROUTER_DYNAMIC_STALETIME, 3e4);
 const PREFETCH_CACHE_TTL = resolveClientRouterStaleTime(process.env.__NEXT_CLIENT_ROUTER_STATIC_STALETIME, 3e4);
-const MIN_PREFETCH_STALE_TIME_MS = 3e4;
+/**
+* Floor for any server-declared `cacheLife` stale time, mirroring Next.js's
+* `getStaleTimeMs` (`Math.max(staleTimeSeconds, 30) * 1000`). One rule for
+* both client caches, so behavior does not depend on which cache a route hit.
+*/
+const MIN_SERVER_STALE_TIME_SECONDS = 30;
+const MIN_PREFETCH_STALE_TIME_MS = MIN_SERVER_STALE_TIME_SECONDS * 1e3;
 function getCurrentInterceptionContext() {
 	if (isServer) return null;
 	return stripBasePath(window.location.pathname, __basePath);
@@ -121,6 +131,15 @@ function getCurrentNextUrl() {
 	if (isServer) return "/";
 	return window.location.pathname + window.location.search;
 }
+function createAppPrefetchRequestHeaders(options) {
+	const prefetchRouterState = getNavigationRuntime()?.functions.getPrefetchRouterState?.() ?? null;
+	return createRscRequestHeaders({
+		...options,
+		nextUrl: getCurrentNextUrl(),
+		includePrefetchHeader: options.prefetchKind !== "full",
+		prefetchRouterState
+	});
+}
 /** Get or create the shared in-memory RSC prefetch cache on window. */
 function getPrefetchCache() {
 	if (isServer) return /* @__PURE__ */ new Map();
@@ -136,31 +155,56 @@ function getPrefetchedUrls() {
 	if (!window.__VINEXT_RSC_PREFETCHED_URLS__) window.__VINEXT_RSC_PREFETCHED_URLS__ = /* @__PURE__ */ new Set();
 	return window.__VINEXT_RSC_PREFETCHED_URLS__;
 }
-function isDynamicStaleTimeSeconds(value) {
+function isStaleTimeSeconds(value) {
 	return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0;
 }
 function isCacheExpiresAt(value) {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
-function parseDynamicStaleTimeSeconds(value) {
+function parseStaleTimeSecondsHeader(value) {
 	if (value === null || value === "") return void 0;
 	const seconds = Number(value);
-	return isDynamicStaleTimeSeconds(seconds) ? seconds : void 0;
+	return isStaleTimeSeconds(seconds) ? seconds : void 0;
+}
+/**
+* The floor a `cacheLife` claim licenses. A pending claim contributes exactly
+* the floor — the least any resolution of it could have granted.
+*/
+function serverStaleTimeSeconds(server) {
+	if (server === void 0) return void 0;
+	if (server.kind === "pending") return MIN_SERVER_STALE_TIME_SECONDS;
+	return Math.max(server.seconds, MIN_SERVER_STALE_TIME_SECONDS);
+}
+/**
+* Min-combine the two independent staleness lattices a response can carry:
+* `dynamicStaleTimeSeconds` (from `experimental.staleTimes` config) and
+* `serverStaleTime` (from the render's `cacheLife`) — neither may override
+* the other. The cacheLife value is floored *before* the min so the floor
+* never raises the config bound. Undefined = no signal; the caller's
+* fallback TTL stays in force.
+*/
+function resolveRscResponseStaleTimeSeconds(cached) {
+	const dynamic = cached.dynamicStaleTimeSeconds;
+	const server = serverStaleTimeSeconds(cached.serverStaleTime);
+	if (!isStaleTimeSeconds(dynamic)) return server;
+	return server === void 0 ? dynamic : Math.min(dynamic, server);
 }
 function resolveCachedRscResponseTtlMs(cached, fallbackTtlMs) {
-	const seconds = cached.dynamicStaleTimeSeconds;
-	if (!isDynamicStaleTimeSeconds(seconds)) return fallbackTtlMs;
+	const seconds = resolveRscResponseStaleTimeSeconds(cached);
+	if (seconds === void 0) return fallbackTtlMs;
 	return seconds * 1e3;
 }
 function resolveCachedRscResponseExpiresAt(timestamp, cached, fallbackTtlMs) {
 	if (isCacheExpiresAt(cached.expiresAt)) return cached.expiresAt;
 	return timestamp + resolveCachedRscResponseTtlMs(cached, fallbackTtlMs);
 }
-function resolvePrefetchedRscResponseExpiresAt(timestamp, cached, fallbackTtlMs) {
+function resolvePrefetchedRscResponseExpiresAt(timestamp, cached, fallbackTtlMs, honorDynamicStaleTime) {
 	if (isCacheExpiresAt(cached.expiresAt)) return cached.expiresAt;
-	const seconds = cached.dynamicStaleTimeSeconds;
-	if (!isDynamicStaleTimeSeconds(seconds)) return timestamp + Math.max(fallbackTtlMs, MIN_PREFETCH_STALE_TIME_MS);
-	return timestamp + Math.max(seconds * 1e3, MIN_PREFETCH_STALE_TIME_MS);
+	const serverSeconds = serverStaleTimeSeconds(cached.serverStaleTime);
+	if (serverSeconds !== void 0) return timestamp + serverSeconds * 1e3;
+	const seconds = isStaleTimeSeconds(cached.dynamicStaleTimeSeconds) ? cached.dynamicStaleTimeSeconds : void 0;
+	if (seconds === void 0) return timestamp + Math.max(fallbackTtlMs, MIN_PREFETCH_STALE_TIME_MS);
+	return honorDynamicStaleTime ? timestamp + seconds * 1e3 : timestamp + Math.max(seconds * 1e3, MIN_PREFETCH_STALE_TIME_MS);
 }
 function resolvePrefetchCacheEntryExpiresAt(entry) {
 	if (entry.expiresAt !== void 0) return entry.expiresAt;
@@ -232,12 +276,9 @@ 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) {
-		touchPrefetchCacheEntry(getPrefetchCache(), match.cacheKey, match.entry);
-		return true;
-	}
-	if (resolvePrefetchCacheEntryExpiresAt(match.entry) > Date.now()) {
+	if (match.entry.pending !== void 0 || resolvePrefetchCacheEntryExpiresAt(match.entry) > Date.now()) {
 		touchPrefetchCacheEntry(getPrefetchCache(), match.cacheKey, match.entry);
+		attachPrefetchInvalidationToEntry(match.cacheKey, match.entry, options.onInvalidate);
 		return true;
 	}
 	deletePrefetchCacheEntry(getPrefetchCache(), getPrefetchedUrls(), match.cacheKey, match.entry, options.notifyInvalidation ?? true);
@@ -328,31 +369,88 @@ function evictPrefetchCacheIfNeeded() {
 		} else break;
 	}
 }
+const pendingPrefetchSetups = /* @__PURE__ */ new Set();
+function beginPrefetchSetup(destination) {
+	const setup = {
+		destination,
+		cancelled: false
+	};
+	pendingPrefetchSetups.add(setup);
+	return setup;
+}
+/** Passing `null` cancels every pending setup regardless of destination. */
+function cancelPendingPrefetchSetups(destination) {
+	for (const setup of pendingPrefetchSetups) if (destination === null || setup.destination === destination) setup.cancelled = true;
+}
+/**
+* Normalize a navigation or prefetch target to the browser href both sides
+* compare on. Returns null when the target is not same-origin — no same-origin
+* prefetch can be a duplicate of it — and on the server, where
+* `navigateClientSide` can still be reached but there is nothing to cancel.
+*/
+function toAppPrefetchDestination(href) {
+	if (isServer) return null;
+	let localHref = href;
+	if (isExternalUrl(href)) {
+		const localPath = toSameOriginAppPath(href, __basePath);
+		if (localPath == null) return null;
+		localHref = localPath;
+	}
+	const browserHref = toBrowserNavigationHref(localHref, window.location.href, __basePath);
+	try {
+		const url = new URL(browserHref, window.location.href);
+		return `${url.pathname}${url.search}`;
+	} catch {
+		return browserHref.split("#", 1)[0];
+	}
+}
 function clearPrefetchInvalidation(entry) {
 	if (entry.invalidationTimer !== void 0) {
 		clearTimeout(entry.invalidationTimer);
 		entry.invalidationTimer = void 0;
 	}
 }
-function notifyPrefetchInvalidated(entry) {
-	clearPrefetchInvalidation(entry);
-	const callbacks = entry.onInvalidateCallbacks;
-	entry.onInvalidateCallbacks = void 0;
-	if (callbacks === void 0) return;
-	for (const onInvalidate of callbacks) try {
+function runInvalidationCallback(onInvalidate) {
+	try {
 		onInvalidate();
 	} catch (error) {
 		if (typeof reportError === "function") reportError(error);
 		else console.error(error);
 	}
 }
+function notifyPrefetchInvalidated(entry) {
+	clearPrefetchInvalidation(entry);
+	const callbacks = entry.onInvalidateCallbacks;
+	entry.onInvalidateCallbacks = void 0;
+	if (callbacks === void 0) return;
+	for (const onInvalidate of callbacks) runInvalidationCallback(onInvalidate);
+}
+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());
+	const retained = {
+		callbacks,
+		timer: setTimeout(() => fireRetainedPrefetchInvalidation(retained), delay)
+	};
+	retainedPrefetchInvalidations.add(retained);
+}
+function fireRetainedPrefetchInvalidation(retained) {
+	if (!retainedPrefetchInvalidations.delete(retained)) return;
+	clearTimeout(retained.timer);
+	for (const onInvalidate of retained.callbacks) runInvalidationCallback(onInvalidate);
+}
 function deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, notify) {
-	adjustPrefetchCacheByteSize(cache, -getPrefetchCacheEntrySize(entry));
 	const cacheKeys = entry.cacheKeys ?? /* @__PURE__ */ new Set([cacheKey]);
-	for (const key of cacheKeys) {
-		if (cache.get(key) === entry) cache.delete(key);
+	let removedOwnedKey = false;
+	for (const key of cacheKeys) if (cache.get(key) === entry) {
+		cache.delete(key);
 		prefetched.delete(key);
+		removedOwnedKey = true;
 	}
+	if (!removedOwnedKey) return;
+	adjustPrefetchCacheByteSize(cache, -getPrefetchCacheEntrySize(entry));
 	entry.cacheKeys = void 0;
 	if (notify) notifyPrefetchInvalidated(entry);
 	else {
@@ -360,6 +458,25 @@ function deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, notify) {
 		entry.onInvalidateCallbacks = void 0;
 	}
 }
+function discardLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext = null) {
+	const cache = getPrefetchCache();
+	const prefetched = getPrefetchedUrls();
+	const normalizedTarget = normalizeRscCacheLookupUrl(rscUrl);
+	if (normalizedTarget === null) return false;
+	const superseded = [];
+	for (const [cacheKey, entry] of cache) {
+		if (entry.cacheForNavigation !== false || entry.prefetchKind !== "navigation") continue;
+		const source = parsePrefetchCacheKey(cacheKey);
+		if (source.interceptionContext !== interceptionContext) continue;
+		if (normalizeRscCacheLookupUrl(source.rscUrl) !== normalizedTarget) continue;
+		superseded.push([cacheKey, entry]);
+	}
+	for (const [cacheKey, entry] of superseded) {
+		cancelAppPrefetchFetch(entry.fetchPromise);
+		deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, true);
+	}
+	return superseded.length > 0;
+}
 function invalidatePrefetchCacheEntry(cacheKey) {
 	const cache = getPrefetchCache();
 	const entry = cache.get(cacheKey);
@@ -379,18 +496,29 @@ function addPrefetchInvalidationCallback(entry, onInvalidate) {
 	if (entry.onInvalidateCallbacks === void 0) entry.onInvalidateCallbacks = /* @__PURE__ */ new Set();
 	entry.onInvalidateCallbacks.add(onInvalidate);
 }
+/**
+* Attach `onInvalidate` to an entry the caller already holds. A settled entry
+* needs its invalidation timer started here — nothing else will schedule one
+* once `prefetchRscResponse` has finished with it.
+*/
+function attachPrefetchInvalidationToEntry(cacheKey, entry, onInvalidate) {
+	if (onInvalidate === void 0) return;
+	addPrefetchInvalidationCallback(entry, onInvalidate);
+	if (entry.outcome === "cache-seeded") schedulePrefetchInvalidation(cacheKey, entry);
+}
 function attachPrefetchInvalidationCallback(cacheKey, onInvalidate) {
 	if (onInvalidate === void 0) return;
 	const entry = getPrefetchCache().get(cacheKey);
 	if (!entry) return;
-	addPrefetchInvalidationCallback(entry, onInvalidate);
-	if (entry.outcome === "cache-seeded") schedulePrefetchInvalidation(cacheKey, entry);
+	attachPrefetchInvalidationToEntry(cacheKey, entry, onInvalidate);
 }
 function invalidatePrefetchCache() {
+	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?.();
 }
 function seedPrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext = null, mountedSlotsHeader = null, fallbackTtlMs = DYNAMIC_NAVIGATION_CACHE_TTL) {
@@ -473,18 +601,42 @@ function storePrefetchResponse(rscUrl, response, interceptionContext = null, opt
 	cache.set(cacheKey, entry);
 }
 function createCachedRscResponseSnapshot(response, buffer, responseUrl = null) {
-	const dynamicStaleTimeSeconds = parseDynamicStaleTimeSeconds(response.headers.get(VINEXT_DYNAMIC_STALE_TIME_HEADER));
+	const headerDynamicStaleTimeSeconds = parseStaleTimeSecondsHeader(response.headers.get(VINEXT_DYNAMIC_STALE_TIME_HEADER));
+	const completionMode = response.headers.get(VINEXT_RSC_COMPLETION_METADATA_HEADER);
+	const extracted = completionMode === "1" ? extractRscCompletionMetadata(buffer) : { buffer };
+	const completedDynamicStaleTimeSeconds = completionMode === "resolved" ? headerDynamicStaleTimeSeconds : extracted.metadata?.dynamicStaleTimeSeconds ?? headerDynamicStaleTimeSeconds;
+	const dynamicStaleTimeSeconds = completedDynamicStaleTimeSeconds ?? headerDynamicStaleTimeSeconds;
+	const parsedServerStaleTime = parseServerStaleTimeHeaders(response.headers);
+	const serverStaleTime = extracted.metadata !== void 0 && Object.hasOwn(extracted.metadata, "serverStaleTimeSeconds") ? extracted.metadata?.serverStaleTimeSeconds === null ? void 0 : {
+		kind: "resolved",
+		seconds: extracted.metadata.serverStaleTimeSeconds
+	} : parsedServerStaleTime;
 	return {
 		compatibilityIdHeader: response.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER),
-		buffer,
+		buffer: extracted.buffer,
+		...completedDynamicStaleTimeSeconds !== void 0 ? { completedDynamicStaleTimeSeconds } : {},
 		contentType: response.headers.get("content-type") ?? "text/x-component",
 		...dynamicStaleTimeSeconds !== void 0 ? { dynamicStaleTimeSeconds } : {},
 		mountedSlotsHeader: response.headers.get(VINEXT_MOUNTED_SLOTS_HEADER),
 		paramsHeader: response.headers.get(VINEXT_PARAMS_HEADER),
 		renderedPathAndSearch: parseRenderedPathAndSearchHeader(response.headers.get(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER)),
+		...serverStaleTime === void 0 ? {} : { serverStaleTime },
 		url: responseUrl ?? response.url
 	};
 }
+/**
+* Collapse the two mutually-exclusive wire headers into one state. A pending
+* marker wins: it says the render committed headers before `cacheLife` settled,
+* so any resolved value alongside it cannot describe the completed render.
+*/
+function parseServerStaleTimeHeaders(headers) {
+	if (headers.get("X-Vinext-Stale-Time-Pending") === "1") return { kind: "pending" };
+	const seconds = parseStaleTimeSecondsHeader(headers.get(NEXT_ROUTER_STALE_TIME_HEADER));
+	return seconds === void 0 ? void 0 : {
+		kind: "resolved",
+		seconds
+	};
+}
 function parseRenderedPathAndSearchHeader(value) {
 	if (value === null || value === "") return null;
 	try {
@@ -524,7 +676,10 @@ function restoreRscResponse(cached, copy = true) {
 	const headers = new Headers({ "content-type": cached.contentType });
 	if (cached.mountedSlotsHeader != null) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, cached.mountedSlotsHeader);
 	if (cached.compatibilityIdHeader != null) headers.set(VINEXT_RSC_COMPATIBILITY_ID_HEADER, cached.compatibilityIdHeader);
-	if (isDynamicStaleTimeSeconds(cached.dynamicStaleTimeSeconds)) headers.set(VINEXT_DYNAMIC_STALE_TIME_HEADER, String(cached.dynamicStaleTimeSeconds));
+	if (isStaleTimeSeconds(cached.dynamicStaleTimeSeconds)) headers.set(VINEXT_DYNAMIC_STALE_TIME_HEADER, String(cached.dynamicStaleTimeSeconds));
+	if (isStaleTimeSeconds(cached.completedDynamicStaleTimeSeconds)) headers.set(VINEXT_RSC_COMPLETION_METADATA_HEADER, "resolved");
+	if (cached.serverStaleTime?.kind === "pending") headers.set(VINEXT_STALE_TIME_PENDING_HEADER, "1");
+	else if (cached.serverStaleTime !== void 0) headers.set(NEXT_ROUTER_STALE_TIME_HEADER, String(cached.serverStaleTime.seconds));
 	if (cached.paramsHeader != null) headers.set(VINEXT_PARAMS_HEADER, cached.paramsHeader);
 	if (cached.renderedPathAndSearch != null) headers.set(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, encodeURIComponent(cached.renderedPathAndSearch));
 	return new Response(copy ? cached.buffer.slice(0) : cached.buffer, {
@@ -533,6 +688,17 @@ function restoreRscResponse(cached, copy = true) {
 	});
 }
 /**
+* `prefetchRscResponse`'s `prepareSnapshot` for navigation-reusable entries:
+* decode the cached payload through the App Router runtime so a later
+* navigation can commit it without re-parsing. Shared by `<Link>` and
+* `router.prefetch()`.
+*/
+async function prepareNavigationPrefetchSnapshot(snapshot) {
+	const preparePrefetchResponse = getNavigationRuntime()?.functions.preparePrefetchResponse;
+	if (!preparePrefetchResponse) throw new Error("App Router prefetch preparation is unavailable");
+	return await preparePrefetchResponse(restoreRscResponse(snapshot));
+}
+/**
 * Prefetch an RSC response and snapshot it for later consumption.
 * Stores the in-flight promise so immediate clicks can await it instead
 * of firing a duplicate fetch.
@@ -557,6 +723,7 @@ function prefetchRscResponse(rscUrl, fetchPromise, interceptionContext = null, m
 		timestamp: now
 	};
 	addPrefetchInvalidationCallback(entry, options?.onInvalidate);
+	entry.fetchPromise = fetchPromise;
 	entry.pending = fetchPromise.then(async (response) => {
 		if (response.ok) {
 			const snapshot = await snapshotRscResponse(response);
@@ -565,7 +732,12 @@ 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);
+			entry.expiresAt = resolvePrefetchedRscResponseExpiresAt(entry.timestamp, entry.snapshot, behavior.fallbackTtlMs ?? PREFETCH_CACHE_TTL, behavior.honorDynamicStaleTime !== false && behavior.searchAgnosticShell !== true);
+			if (behavior.prepareSnapshot) try {
+				const preparedElements = await behavior.prepareSnapshot(snapshot);
+				if (cache.get(cacheKey) !== entry) return;
+				entry.preparedElements = preparedElements;
+			} catch {}
 			addRenderedPathAndSearchPrefetchAlias(cache, prefetched, cacheKey, entry);
 			evictPrefetchCacheIfNeeded();
 		} else {
@@ -577,6 +749,7 @@ function prefetchRscResponse(rscUrl, fetchPromise, interceptionContext = null, m
 	}).finally(() => {
 		if (cache.get(cacheKey) !== entry) return;
 		entry.pending = void 0;
+		entry.fetchPromise = void 0;
 		if (entry.snapshot) {
 			entry.outcome = "cache-seeded";
 			schedulePrefetchInvalidation(cacheKey, entry);
@@ -599,8 +772,8 @@ function addRenderedPathAndSearchPrefetchAlias(cache, prefetched, primaryCacheKe
 	cache.set(aliasCacheKey, entry);
 	prefetched.add(aliasCacheKey);
 }
-function peekPrefetchResponseForNavigation(rscUrl, interceptionContext = null, mountedSlotsHeader = null) {
-	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader);
+function peekPrefetchResponseForNavigation(rscUrl, interceptionContext = null, mountedSlotsHeader = null, options) {
+	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, options?.additionalRscUrls);
 	if (!match) return null;
 	const { cacheKey, entry } = match;
 	if (entry.pending || entry.outcome !== "cache-seeded") return null;
@@ -620,28 +793,38 @@ function peekPrefetchResponseForNavigation(rscUrl, interceptionContext = null, m
 * Only returns settled (non-pending) snapshots synchronously.
 * Returns null if the entry is still in flight or doesn't exist.
 */
-function consumePrefetchResponse(rscUrl, interceptionContext = null, mountedSlotsHeader = null) {
+function consumePrefetchResponse(rscUrl, interceptionContext = null, mountedSlotsHeader = null, options) {
 	const cache = getPrefetchCache();
 	const exactCacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 	const exactEntry = cache.get(exactCacheKey);
 	if (exactEntry && exactEntry.cacheForNavigation !== false && !isPrefetchCacheEntryCompatibleWithMountedSlots(exactEntry, mountedSlotsHeader)) deletePrefetchCacheEntry(cache, getPrefetchedUrls(), exactCacheKey, exactEntry, false);
-	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader);
+	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, options?.additionalRscUrls);
 	if (!match) return null;
 	const { cacheKey, entry } = match;
 	return consumeMatchedPrefetchResponse(cacheKey, entry, mountedSlotsHeader);
 }
-function consumeMatchedPrefetchResponse(cacheKey, entry, mountedSlotsHeader) {
+function consumeMatchedPrefetchResponse(cacheKey, entry, mountedSlotsHeader, allowExpiredInFlightHandoff = false) {
+	const cache = getPrefetchCache();
 	if (entry.pending || entry.outcome !== "cache-seeded") return null;
 	if (entry.cacheForNavigation === false) return null;
-	deletePrefetchCacheEntry(getPrefetchCache(), getPrefetchedUrls(), cacheKey, entry, false);
 	if (entry.snapshot) {
 		if (!isPrefetchCacheEntryCompatibleWithMountedSlots(entry, mountedSlotsHeader)) return null;
-		if (resolvePrefetchCacheEntryExpiresAt(entry) <= Date.now()) return null;
+		if (!allowExpiredInFlightHandoff && resolvePrefetchCacheEntryExpiresAt(entry) <= Date.now()) {
+			deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, entry, true);
+			return null;
+		}
+		retainPrefetchInvalidationAfterConsume(entry);
+		deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, entry, false);
+		const snapshot = entry.snapshot;
 		if (entry.expiresAt !== void 0 || entry.snapshot.expiresAt !== void 0) return {
-			...entry.snapshot,
-			expiresAt: resolvePrefetchCacheEntryExpiresAt(entry)
+			...snapshot,
+			expiresAt: resolvePrefetchCacheEntryExpiresAt(entry),
+			...entry.preparedElements ? { preparedElements: entry.preparedElements } : {}
 		};
-		return entry.snapshot;
+		return entry.preparedElements ? {
+			...snapshot,
+			preparedElements: entry.preparedElements
+		} : snapshot;
 	}
 	return null;
 }
@@ -650,12 +833,15 @@ async function consumePrefetchResponseForNavigation(rscUrl, interceptionContext
 	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, options?.additionalRscUrls);
 	if (!match) return null;
 	const { cacheKey, entry } = match;
+	if (options?.shouldConsume?.() === false) return null;
+	const allowExpiredInFlightHandoff = entry.pending !== void 0;
 	if (entry.pending !== void 0) {
+		promoteAppPrefetchFetch(entry.fetchPromise);
 		await entry.pending.catch(() => {});
 		if (cache.get(cacheKey) !== entry) return null;
+		if (options?.shouldConsume?.() === false) return null;
 	}
-	if (options?.shouldConsume?.() === false) return null;
-	return consumeMatchedPrefetchResponse(cacheKey, entry, mountedSlotsHeader);
+	return consumeMatchedPrefetchResponse(cacheKey, entry, mountedSlotsHeader, allowExpiredInFlightHandoff);
 }
 const _CLIENT_NAV_STATE_KEY = Symbol.for("vinext.clientNavigationState");
 const _MOUNTED_SLOTS_HEADER_KEY = Symbol.for("vinext.mountedSlotsHeader");
@@ -1036,7 +1222,7 @@ function commitHashOnlyHistoryState(href, mode, scroll) {
 function applyAppRouterScrollFallback(intent) {
 	if (typeof document === "undefined" || typeof window === "undefined") return;
 	if (intent.hash !== null) {
-		scrollToHashTarget(intent.hash);
+		scrollToHashTargetOnNextFrame(intent.hash, () => isLatestAppRouterScrollIntent(intent));
 		return;
 	}
 	if (intent.targetHoistedInHead) return;
@@ -1085,10 +1271,43 @@ function hardNavigateTo(fullHref, mode) {
 	else window.location.assign(fullHref);
 }
 /**
+* Reset any link still showing a `useLinkStatus()` pending state that did not
+* initiate the navigation now starting (e.g. a programmatic router.push, a form
+* submit, or a raw history update). A <Link> click registers itself first, so
+* the hook keeps that link pending.
+*/
+function resetStaleLinkStatus() {
+	getNavigationRuntime()?.functions.notifyLinkNavigationStart?.();
+}
+/**
+* Signal that a navigation to `href` is starting, for the callers that will
+* fetch the destination. Separate from `resetStaleLinkStatus()` because a raw
+* `history.pushState` also supersedes a pending link but issues no request —
+* cancelling a prefetch there would drop it with nothing to take its place.
+*/
+function notifyAppNavigationStart(href) {
+	const destination = toAppPrefetchDestination(href);
+	if (destination !== null && !isHashOnlyBrowserUrlChange(href, window.location.href, __basePath)) cancelPendingPrefetchSetups(destination);
+	resetStaleLinkStatus();
+}
+/**
+* popstate variant. The browser has already applied the history entry by the
+* time this runs, so the pre-navigation URL that `isHashOnlyBrowserUrlChange`
+* needs is gone. Back/forward across a route boundary does drive an RSC fetch
+* (`app-browser-entry.ts`'s popstate handler), so cancelling by destination is
+* right; a hash-only entry over-cancels, which costs one re-prefetch and can
+* never cause a duplicate request.
+*/
+function notifyAppPopstateNavigationStart() {
+	const destination = toAppPrefetchDestination(window.location.href);
+	if (destination !== null) cancelPendingPrefetchSetups(destination);
+	resetStaleLinkStatus();
+}
+/**
 * Navigate to a URL, handling external URLs, hash-only changes, and RSC navigation.
 */
 async function navigateClientSide(href, mode, scroll, programmaticTransition = false, visibleCommitMode = "transition") {
-	getNavigationRuntime()?.functions.notifyLinkNavigationStart?.();
+	notifyAppNavigationStart(href);
 	let normalizedHref = href;
 	if (isExternalUrl(href)) {
 		const localPath = toSameOriginAppPath(href, __basePath);
@@ -1191,7 +1410,7 @@ const _appRouter = {
 	push(href, options) {
 		assertSafeNavigationUrl(href);
 		if (isServer) return;
-		getNavigationRuntime()?.functions.notifyLinkNavigationStart?.();
+		notifyAppNavigationStart(href);
 		const releaseNavigation = trackScheduledAppRouterNavigation();
 		try {
 			React$1.startTransition(() => {
@@ -1206,7 +1425,7 @@ const _appRouter = {
 	replace(href, options) {
 		assertSafeNavigationUrl(href);
 		if (isServer) return;
-		getNavigationRuntime()?.functions.notifyLinkNavigationStart?.();
+		notifyAppNavigationStart(href);
 		const releaseNavigation = trackScheduledAppRouterNavigation();
 		try {
 			React$1.startTransition(() => {
@@ -1247,35 +1466,68 @@ const _appRouter = {
 		} catch {
 			throw new Error(`Cannot prefetch '${href}' because it cannot be converted to a URL.`);
 		}
+		const prefetchHref = isExternalUrl(href) ? toSameOriginAppPath(href, __basePath) : href;
+		if (prefetchHref == null) return;
+		const fullHref = toAppPrefetchDestination(prefetchHref);
+		if (fullHref === null) return;
+		const interceptionContext = getPrefetchInterceptionContext(fullHref);
+		const mountedSlotsHeader = getMountedSlotsHeader();
+		const headers = createAppPrefetchRequestHeaders({
+			fetchPriority: "low",
+			interceptionContext,
+			mountedSlotsHeader: mountedSlotsHeader || null
+		});
+		const setup = beginPrefetchSetup(fullHref);
 		(async () => {
-			let prefetchHref = href;
-			if (isExternalUrl(href)) {
-				const localPath = toSameOriginAppPath(href, __basePath);
-				if (localPath == null) return;
-				prefetchHref = localPath;
-			}
-			const hybridOwner = resolveHybridClientRouteOwner(prefetchHref);
+			if (HAS_CLIENT_REWRITES) await preloadHybridClientRouteOwner();
+			const hybridOwner = resolveHybridClientRouteOwner(fullHref);
 			if (hybridOwner === "pages" || hybridOwner === "document") return;
-			const fullHref = toBrowserNavigationHref(prefetchHref, window.location.href, __basePath);
-			const interceptionContext = getPrefetchInterceptionContext(fullHref);
-			const mountedSlotsHeader = getMountedSlotsHeader();
-			const headers = createRscRequestHeaders({ interceptionContext });
-			if (mountedSlotsHeader) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, mountedSlotsHeader);
-			const rscUrl = await createRscRequestUrl(fullHref, headers);
+			const rewrittenPrefetchHref = HAS_CLIENT_REWRITES ? resolveLoadedHybridClientRewriteHref(fullHref, __basePath) : null;
+			const kind = options?.kind === "full" ? "full" : "auto";
+			const { resolveAutoAppRoutePrefetch, resolveFullAppRoutePrefetch } = await import("./internal/app-route-prefetch-policy.js");
+			const policy = kind === "full" ? resolveFullAppRoutePrefetch() : resolveAutoAppRoutePrefetch(rewrittenPrefetchHref ?? fullHref);
+			const reusable = policy.shouldPrefetch && policy.cacheForNavigation;
+			if (reusable && kind === "full") headers.delete(NEXT_ROUTER_PREFETCH_HEADER);
+			if (reusable && kind === "auto") {
+				headers.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+				headers.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, __prefetchInlining ? "/__PAGE__" : "1");
+			}
+			const [rscUrl, ...additionalRscUrls] = await Promise.all([createRscRequestUrl(fullHref, headers), ...rewrittenPrefetchHref !== null && rewrittenPrefetchHref !== fullHref ? [createRscRequestUrl(rewrittenPrefetchHref, headers)] : []]);
+			if (setup.cancelled) return;
 			const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 			const prefetched = getPrefetchedUrls();
-			if (prefetched.has(cacheKey)) {
+			if (reusable) {
+				discardLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext);
+				if (hasPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, {
+					additionalRscUrls,
+					onInvalidate: options?.onInvalidate
+				})) return;
+			} else if (prefetched.has(cacheKey)) {
 				attachPrefetchInvalidationCallback(cacheKey, options?.onInvalidate);
 				return;
 			}
 			prefetched.add(cacheKey);
-			prefetchRscResponse(rscUrl, scheduleAppPrefetchFetch(() => fetch(rscUrl, {
+			prefetchRscResponse(rscUrl, scheduleAppPrefetchFetch((signal) => fetch(rscUrl, {
 				headers,
 				credentials: "include",
-				priority: "low"
-			}), "low"), interceptionContext, mountedSlotsHeader, options);
+				priority: "low",
+				signal
+			}), "low"), interceptionContext, mountedSlotsHeader, options, reusable ? {
+				cacheForNavigation: true,
+				fallbackTtlMs: policy.fallbackTtl === "dynamic" ? DYNAMIC_NAVIGATION_CACHE_TTL : PREFETCH_CACHE_TTL,
+				honorDynamicStaleTime: policy.honorDynamicStaleTime,
+				optimisticRouteShell: false,
+				prefetchKind: "navigation",
+				prepareSnapshot: prepareNavigationPrefetchSnapshot
+			} : {
+				cacheForNavigation: false,
+				optimisticRouteShell: true,
+				prefetchKind: "navigation"
+			});
 		})().catch((error) => {
 			console.error("[vinext] RSC prefetch setup error:", error);
+		}).finally(() => {
+			pendingPrefetchSetups.delete(setup);
 		});
 	}
 };
@@ -1387,7 +1639,7 @@ if (!isServer) {
 	if (state && !state.patchInstalled) {
 		state.patchInstalled = true;
 		window.addEventListener("popstate", () => {
-			getNavigationRuntime()?.functions.notifyLinkNavigationStart?.();
+			notifyAppPopstateNavigationStart();
 		});
 		window.addEventListener("popstate", (event) => {
 			if (!hasAppNavigationRuntime()) {
@@ -1398,18 +1650,18 @@ if (!isServer) {
 		window.history.pushState = function patchedPushState(data, unused, url) {
 			state.originalPushState.call(window.history, createExternalHistoryStatePreservingMetadata(data, window.history.state), unused, url);
 			if (state.suppressUrlNotifyCount === 0) {
-				getNavigationRuntime()?.functions.notifyLinkNavigationStart?.();
+				resetStaleLinkStatus();
 				commitClientNavigationState();
 			}
 		};
 		window.history.replaceState = function patchedReplaceState(data, unused, url) {
 			state.originalReplaceState.call(window.history, createExternalHistoryStatePreservingMetadata(data, window.history.state), unused, url);
 			if (state.suppressUrlNotifyCount === 0) {
-				getNavigationRuntime()?.functions.notifyLinkNavigationStart?.();
+				resetStaleLinkStatus();
 				commitClientNavigationState();
 			}
 		};
 	}
 }
 //#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, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, decodeRedirectError, deletePrefetchResponseSnapshot, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getClientNavigationRenderContext, getClientNavigationState, getClientParams, getCurrentInterceptionContext, getCurrentNextUrl, getLayoutSegmentContext, getMountedSlotsHeader, getNavigationContext, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, hasSearchAgnosticPrefetchShellForRoute, invalidatePrefetchCache, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, navigateClientSide, notFound, peekPrefetchResponseForNavigation, permanentRedirect, prefetchRscResponse, preloadHybridClientRouteOwner, 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, discardLearningOnlyPrefetchCacheEntry, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getClientNavigationRenderContext, getClientNavigationState, getClientParams, getCurrentInterceptionContext, getCurrentNextUrl, getLayoutSegmentContext, getMountedSlotsHeader, getNavigationContext, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, hasSearchAgnosticPrefetchShellForRoute, invalidatePrefetchCache, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, navigateClientSide, notFound, 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 };