vinext 0.1.8 → 0.2.1

package/dist/shims/navigation.js

@@ -1,18 +1,18 @@
 import { stripBasePath } from "../utils/base-path.js";
-import { VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER } from "../server/headers.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 { assertSafeNavigationUrl } from "./url-safety.js";
 import { AppElementsWire } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
 import { markPprFallbackShellDynamicBoundary } from "./ppr-fallback-shell.js";
 import { AppRouterContext } from "./internal/app-router-context.js";
-import { resolveHybridClientRouteOwner } from "./internal/hybrid-client-route-owner.js";
 import { isAbsoluteOrProtocolRelativeUrl, toBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
 import { retryScrollTo, scrollToHashTarget } from "./hash-scroll.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 { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { clearAppNavigationFailureTarget, stageAppNavigationFailureTarget } from "../client/app-nav-failure-handler.js";
 import { beginAppRouterScrollIntent, clearAppRouterScrollIntent, consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent } from "./app-router-scroll-state.js";
-import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createRscRequestHeaders, createRscRequestUrl, stripRscCacheBustingSearchParam } from "../server/app-rsc-cache-busting.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";
@@ -22,6 +22,8 @@ import { hasPendingAppRouterPageRedirect } from "../server/app-browser-mpa-navig
 import { navigationPlanner } from "../server/navigation-planner.js";
 import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
 import { getPagesNavigationContext } from "./internal/pages-router-accessor.js";
+import { resolveHybridClientRouteOwner } from "./internal/hybrid-client-route-owner.js";
+import { 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
@@ -41,7 +43,7 @@ function useChildSegments(parallelRoutesKey = "children") {
 	const ctx = getLayoutSegmentContext();
 	if (!ctx) return [];
 	try {
-		return React$1.useContext(ctx)[parallelRoutesKey] ?? [];
+		return (React$1.useContext(ctx)[parallelRoutesKey] ?? []).filter((segment) => !segment.startsWith("__PAGE__"));
 	} catch {
 		return [];
 	}
@@ -53,8 +55,9 @@ 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 ?? "";
-/** Maximum number of entries in the RSC prefetch cache. */
-const MAX_PREFETCH_CACHE_SIZE = 50;
+/** 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;
 /**
 * TTL for prefetch cache entries in ms.
 *
@@ -69,14 +72,15 @@ const MAX_PREFETCH_CACHE_SIZE = 50;
 * has not set `experimental.staleTimes`, Next.js' 300s default applies
 * (see `resolveStaleTimes` in `config/next-config.ts`).
 */
-function resolvePrefetchCacheTtl() {
-	const raw = process.env.__NEXT_CLIENT_ROUTER_STATIC_STALETIME;
-	if (raw === void 0 || raw === "") return 3e4;
+function resolveClientRouterStaleTime(raw, fallbackMs) {
+	if (raw === void 0 || raw === "") return fallbackMs;
 	const seconds = Number(raw);
-	if (!Number.isFinite(seconds) || seconds < 0) return 3e4;
+	if (!Number.isFinite(seconds) || seconds < 0) return fallbackMs;
 	return seconds * 1e3;
 }
-const PREFETCH_CACHE_TTL = resolvePrefetchCacheTtl();
+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;
 function getCurrentInterceptionContext() {
 	if (isServer) return null;
 	return stripBasePath(window.location.pathname, __basePath);
@@ -135,6 +139,12 @@ function resolveCachedRscResponseExpiresAt(timestamp, cached, fallbackTtlMs) {
 	if (isCacheExpiresAt(cached.expiresAt)) return cached.expiresAt;
 	return timestamp + resolveCachedRscResponseTtlMs(cached, fallbackTtlMs);
 }
+function resolvePrefetchedRscResponseExpiresAt(timestamp, cached, fallbackTtlMs) {
+	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);
+}
 function resolvePrefetchCacheEntryExpiresAt(entry) {
 	if (entry.expiresAt !== void 0) return entry.expiresAt;
 	if (entry.snapshot) return resolveCachedRscResponseExpiresAt(entry.timestamp, entry.snapshot, PREFETCH_CACHE_TTL);
@@ -153,6 +163,13 @@ function normalizeRscCacheLookupUrl(rscUrl) {
 		return null;
 	}
 }
+function normalizeRscCacheLookupPathname(rscUrl) {
+	try {
+		return stripRscSuffix(new URL(rscUrl, "http://vinext.local").pathname);
+	} catch {
+		return null;
+	}
+}
 function parsePrefetchCacheKey(cacheKey) {
 	const separatorIndex = cacheKey.indexOf("\0");
 	if (separatorIndex === -1) return {
@@ -168,22 +185,25 @@ function isPrefetchCacheEntryCompatibleWithMountedSlots(entry, mountedSlotsHeade
 	if (resolvePrefetchCacheEntryMountedSlotsHeader(entry) === mountedSlotsHeader) return true;
 	return (entry.snapshot?.mountedSlotsHeader ?? null) === mountedSlotsHeader;
 }
-function findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader) {
-	const exactCacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
+function findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, additionalRscUrls = []) {
 	const cache = getPrefetchCache();
-	const exactEntry = cache.get(exactCacheKey);
-	if (exactEntry && exactEntry.cacheForNavigation !== false && isPrefetchCacheEntryCompatibleWithMountedSlots(exactEntry, mountedSlotsHeader)) return {
-		cacheKey: exactCacheKey,
-		entry: exactEntry
-	};
-	const normalizedTarget = normalizeRscCacheLookupUrl(rscUrl);
-	if (normalizedTarget === null) return null;
+	const rscUrls = [rscUrl, ...additionalRscUrls];
+	for (const lookupRscUrl of rscUrls) {
+		const exactCacheKey = AppElementsWire.encodeCacheKey(lookupRscUrl, interceptionContext);
+		const exactEntry = cache.get(exactCacheKey);
+		if (exactEntry && exactEntry.cacheForNavigation !== false && isPrefetchCacheEntryCompatibleWithMountedSlots(exactEntry, mountedSlotsHeader)) return {
+			cacheKey: exactCacheKey,
+			entry: exactEntry
+		};
+	}
+	const normalizedTargets = new Set(rscUrls.map((lookupRscUrl) => normalizeRscCacheLookupUrl(lookupRscUrl)).filter((lookupRscUrl) => lookupRscUrl !== null));
+	if (normalizedTargets.size === 0) return null;
 	for (const [cacheKey, entry] of cache) {
-		if (cacheKey === exactCacheKey) continue;
 		if (entry.cacheForNavigation === false) continue;
 		const source = parsePrefetchCacheKey(cacheKey);
 		if (source.interceptionContext !== interceptionContext) continue;
-		if (normalizeRscCacheLookupUrl(source.rscUrl) !== normalizedTarget) continue;
+		const normalizedSource = normalizeRscCacheLookupUrl(source.rscUrl);
+		if (normalizedSource === null || !normalizedTargets.has(normalizedSource)) continue;
 		if (!isPrefetchCacheEntryCompatibleWithMountedSlots(entry, mountedSlotsHeader)) continue;
 		return {
 			cacheKey,
@@ -193,31 +213,100 @@ function findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mounte
 	return null;
 }
 function hasPrefetchCacheEntryForNavigation(rscUrl, interceptionContext = null, mountedSlotsHeader = null, options = {}) {
-	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader);
+	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, options.additionalRscUrls);
 	if (match === null) return false;
-	if (match.entry.pending !== void 0) return true;
-	if (resolvePrefetchCacheEntryExpiresAt(match.entry) > Date.now()) return true;
+	if (match.entry.pending !== void 0) {
+		touchPrefetchCacheEntry(getPrefetchCache(), match.cacheKey, match.entry);
+		return true;
+	}
+	if (resolvePrefetchCacheEntryExpiresAt(match.entry) > Date.now()) {
+		touchPrefetchCacheEntry(getPrefetchCache(), match.cacheKey, match.entry);
+		return true;
+	}
 	deletePrefetchCacheEntry(getPrefetchCache(), getPrefetchedUrls(), match.cacheKey, match.entry, options.notifyInvalidation ?? true);
 	return false;
 }
+function hasSearchAgnosticPrefetchShellForRoute(rscUrl, interceptionContext = null, mountedSlotsHeader = null) {
+	const normalizedTargetPathname = normalizeRscCacheLookupPathname(rscUrl);
+	if (normalizedTargetPathname === null) return false;
+	const cache = getPrefetchCache();
+	for (const [cacheKey, entry] of cache) {
+		if (entry.searchAgnosticShell !== true) continue;
+		const source = parsePrefetchCacheKey(cacheKey);
+		if (source.interceptionContext !== interceptionContext) continue;
+		if (normalizeRscCacheLookupPathname(source.rscUrl) !== normalizedTargetPathname) continue;
+		if (!isPrefetchCacheEntryCompatibleWithMountedSlots(entry, mountedSlotsHeader)) continue;
+		if (entry.pending !== void 0) return true;
+		if (resolvePrefetchCacheEntryExpiresAt(entry) > Date.now()) return true;
+		deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, entry, true);
+	}
+	return false;
+}
+function getPrefetchCacheEntrySize(entry) {
+	return entry.snapshot?.buffer.byteLength ?? entry.size ?? 0;
+}
+let trackedPrefetchCache = null;
+let trackedPrefetchCacheByteSize = 0;
+function getPrefetchCacheByteSize(cache) {
+	if (trackedPrefetchCache === cache) return trackedPrefetchCacheByteSize;
+	let total = 0;
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of cache.values()) {
+		if (seen.has(entry)) continue;
+		seen.add(entry);
+		total += getPrefetchCacheEntrySize(entry);
+	}
+	trackedPrefetchCache = cache;
+	trackedPrefetchCacheByteSize = total;
+	return total;
+}
+function adjustPrefetchCacheByteSize(cache, delta) {
+	if (trackedPrefetchCache !== cache) return;
+	trackedPrefetchCacheByteSize = Math.max(0, trackedPrefetchCacheByteSize + delta);
+}
+function touchPrefetchCacheEntry(cache, cacheKey, entry) {
+	if (cache.get(cacheKey) !== entry) return;
+	cache.delete(cacheKey);
+	cache.set(cacheKey, entry);
+	for (const key of entry.cacheKeys ?? []) {
+		if (key === cacheKey || cache.get(key) !== entry) continue;
+		cache.delete(key);
+		cache.set(key, entry);
+	}
+}
 /**
-* Evict prefetch cache entries if at capacity.
-* First sweeps expired entries, then falls back to FIFO eviction.
+* Evict prefetch cache entries if buffered payloads exceed the byte budget.
+* Sweeps expired entries only after the cheap byte-budget check says cleanup is
+* needed, then evicts least-recently-used entries down to the target size.
 */
 function evictPrefetchCacheIfNeeded() {
 	const cache = getPrefetchCache();
-	if (cache.size < 50) return;
+	let totalSize = getPrefetchCacheByteSize(cache);
+	if (totalSize <= 52428800) return;
 	const now = Date.now();
 	const prefetched = getPrefetchedUrls();
 	for (const [key, entry] of cache) if (resolvePrefetchCacheEntryExpiresAt(entry) <= now) deletePrefetchCacheEntry(cache, prefetched, key, entry, true);
-	while (cache.size >= 50) {
+	totalSize = getPrefetchCacheByteSize(cache);
+	if (totalSize <= 52428800) return;
+	let inspectedEntries = 0;
+	while (totalSize > PREFETCH_CACHE_EVICTION_TARGET_SIZE && inspectedEntries < cache.size) {
 		const oldest = cache.keys().next().value;
 		if (oldest !== void 0) {
 			const entry = cache.get(oldest);
-			if (entry) deletePrefetchCacheEntry(cache, prefetched, oldest, entry, true);
-			else {
+			if (entry) {
+				const entrySize = getPrefetchCacheEntrySize(entry);
+				if (entry.pending !== void 0 && entrySize === 0) {
+					touchPrefetchCacheEntry(cache, oldest, entry);
+					inspectedEntries += 1;
+					continue;
+				}
+				totalSize -= entrySize;
+				deletePrefetchCacheEntry(cache, prefetched, oldest, entry, true);
+				inspectedEntries = 0;
+			} else {
 				cache.delete(oldest);
 				prefetched.delete(oldest);
+				inspectedEntries += 1;
 			}
 		} else break;
 	}
@@ -241,8 +330,13 @@ function notifyPrefetchInvalidated(entry) {
 	}
 }
 function deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, notify) {
-	cache.delete(cacheKey);
-	prefetched.delete(cacheKey);
+	adjustPrefetchCacheByteSize(cache, -getPrefetchCacheEntrySize(entry));
+	const cacheKeys = entry.cacheKeys ?? new Set([cacheKey]);
+	for (const key of cacheKeys) {
+		if (cache.get(key) === entry) cache.delete(key);
+		prefetched.delete(key);
+	}
+	entry.cacheKeys = void 0;
 	if (notify) notifyPrefetchInvalidated(entry);
 	else {
 		clearPrefetchInvalidation(entry);
@@ -282,6 +376,35 @@ function invalidatePrefetchCache() {
 	prefetched.clear();
 	if (!isServer) getNavigationRuntime()?.functions.pingVisibleLinks?.();
 }
+function seedPrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext = null, mountedSlotsHeader = null, fallbackTtlMs = DYNAMIC_NAVIGATION_CACHE_TTL) {
+	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
+	const cache = getPrefetchCache();
+	const existing = cache.get(cacheKey);
+	if (existing) deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, existing, false);
+	const timestamp = Date.now();
+	const entry = {
+		cacheForNavigation: true,
+		cacheKeys: new Set([cacheKey]),
+		expiresAt: resolveCachedRscResponseExpiresAt(timestamp, snapshot, fallbackTtlMs),
+		mountedSlotsHeader,
+		outcome: "cache-seeded",
+		size: snapshot.buffer.byteLength,
+		snapshot,
+		timestamp
+	};
+	cache.set(cacheKey, entry);
+	adjustPrefetchCacheByteSize(cache, snapshot.buffer.byteLength);
+	getPrefetchedUrls().add(cacheKey);
+	schedulePrefetchInvalidation(cacheKey, entry);
+	evictPrefetchCacheIfNeeded();
+}
+function deletePrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext = null) {
+	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
+	const cache = getPrefetchCache();
+	const entry = cache.get(cacheKey);
+	if (entry?.snapshot !== snapshot) return;
+	deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, entry, false);
+}
 /**
 * Store a prefetched RSC response in the cache by snapshotting it to an
 * ArrayBuffer.  The snapshot completes asynchronously; during that window
@@ -300,27 +423,37 @@ function invalidatePrefetchCache() {
 */
 function storePrefetchResponse(rscUrl, response, interceptionContext = null, options) {
 	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
-	evictPrefetchCacheIfNeeded();
+	const cache = getPrefetchCache();
+	const prefetched = getPrefetchedUrls();
+	const existing = cache.get(cacheKey);
+	if (existing) deletePrefetchCacheEntry(cache, prefetched, cacheKey, existing, false);
 	const entry = {
+		cacheKeys: new Set([cacheKey]),
 		mountedSlotsHeader: null,
 		outcome: "pending",
 		timestamp: Date.now()
 	};
 	addPrefetchInvalidationCallback(entry, options?.onInvalidate);
 	entry.pending = snapshotRscResponse(response).then((snapshot) => {
+		if (cache.get(cacheKey) !== entry) return;
+		const previousSize = getPrefetchCacheEntrySize(entry);
 		entry.mountedSlotsHeader = snapshot.mountedSlotsHeader ?? null;
 		entry.snapshot = snapshot;
+		entry.size = snapshot.buffer.byteLength;
+		adjustPrefetchCacheByteSize(cache, entry.size - previousSize);
 		entry.expiresAt = resolveCachedRscResponseExpiresAt(entry.timestamp, snapshot, PREFETCH_CACHE_TTL);
+		evictPrefetchCacheIfNeeded();
 	}).catch(() => {
-		deletePrefetchCacheEntry(getPrefetchCache(), getPrefetchedUrls(), cacheKey, entry, false);
+		deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, false);
 	}).finally(() => {
+		if (cache.get(cacheKey) !== entry) return;
 		entry.pending = void 0;
 		if (entry.snapshot) {
 			entry.outcome = "cache-seeded";
 			schedulePrefetchInvalidation(cacheKey, entry);
 		}
 	});
-	getPrefetchCache().set(cacheKey, entry);
+	cache.set(cacheKey, entry);
 }
 function createCachedRscResponseSnapshot(response, buffer, responseUrl = null) {
 	const dynamicStaleTimeSeconds = parseDynamicStaleTimeSeconds(response.headers.get(VINEXT_DYNAMIC_STALE_TIME_HEADER));
@@ -331,15 +464,29 @@ 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),
+		renderedPathAndSearch: parseRenderedPathAndSearchHeader(response.headers.get(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER)),
 		url: responseUrl ?? response.url
 	};
 }
+function parseRenderedPathAndSearchHeader(value) {
+	if (value === null || value === "") return null;
+	try {
+		const decoded = decodeURIComponent(value);
+		return decoded.startsWith("/") ? decoded : null;
+	} catch {
+		return null;
+	}
+}
 /**
 * Snapshot an RSC response to an ArrayBuffer for caching and replay.
 * Consumes the response body and stores it with content-type and URL metadata.
 */
 async function snapshotRscResponse(response) {
-	return createCachedRscResponseSnapshot(response, await response.arrayBuffer());
+	try {
+		return createCachedRscResponseSnapshot(response, await response.arrayBuffer());
+	} finally {
+		releaseAppPrefetchFetchSlot(response);
+	}
 }
 /**
 * Reconstruct a Response from a cached RSC snapshot.
@@ -362,6 +509,7 @@ function restoreRscResponse(cached, copy = true) {
 	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 (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, {
 		status: 200,
 		headers
@@ -379,22 +527,38 @@ function prefetchRscResponse(rscUrl, fetchPromise, interceptionContext = null, m
 	const cache = getPrefetchCache();
 	const prefetched = getPrefetchedUrls();
 	const now = Date.now();
+	const existing = cache.get(cacheKey);
+	if (existing) deletePrefetchCacheEntry(cache, prefetched, cacheKey, existing, false);
 	const entry = {
 		cacheForNavigation: behavior.cacheForNavigation ?? true,
+		cacheKeys: new Set([cacheKey]),
 		mountedSlotsHeader,
 		optimisticRouteShell: behavior.optimisticRouteShell === true,
 		outcome: "pending",
+		prefetchKind: behavior.prefetchKind ?? (behavior.optimisticRouteShell === true ? "loading-shell" : "navigation"),
+		searchAgnosticShell: behavior.searchAgnosticShell === true,
 		timestamp: now
 	};
 	addPrefetchInvalidationCallback(entry, options?.onInvalidate);
 	entry.pending = fetchPromise.then(async (response) => {
 		if (response.ok) {
-			entry.snapshot = await snapshotRscResponse(response);
-			entry.expiresAt = resolveCachedRscResponseExpiresAt(entry.timestamp, entry.snapshot, PREFETCH_CACHE_TTL);
-		} else deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, false);
+			const snapshot = await snapshotRscResponse(response);
+			if (cache.get(cacheKey) !== entry) return;
+			const previousSize = getPrefetchCacheEntrySize(entry);
+			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);
+			addRenderedPathAndSearchPrefetchAlias(cache, prefetched, cacheKey, entry);
+			evictPrefetchCacheIfNeeded();
+		} else {
+			releaseAppPrefetchFetchSlot(response);
+			deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, false);
+		}
 	}).catch(() => {
 		deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, false);
 	}).finally(() => {
+		if (cache.get(cacheKey) !== entry) return;
 		entry.pending = void 0;
 		if (entry.snapshot) {
 			entry.outcome = "cache-seeded";
@@ -404,6 +568,36 @@ function prefetchRscResponse(rscUrl, fetchPromise, interceptionContext = null, m
 	cache.set(cacheKey, entry);
 	evictPrefetchCacheIfNeeded();
 }
+function addRenderedPathAndSearchPrefetchAlias(cache, prefetched, primaryCacheKey, entry) {
+	if (entry.cacheForNavigation === false) return;
+	const renderedPathAndSearch = entry.snapshot?.renderedPathAndSearch;
+	if (!renderedPathAndSearch) return;
+	const source = parsePrefetchCacheKey(primaryCacheKey);
+	const aliasCacheKey = AppElementsWire.encodeCacheKey(renderedPathAndSearch, source.interceptionContext);
+	if (aliasCacheKey === primaryCacheKey) return;
+	const existing = cache.get(aliasCacheKey);
+	if (existing && existing !== entry) deletePrefetchCacheEntry(cache, prefetched, aliasCacheKey, existing, false);
+	entry.cacheKeys ??= new Set([primaryCacheKey]);
+	entry.cacheKeys.add(aliasCacheKey);
+	cache.set(aliasCacheKey, entry);
+	prefetched.add(aliasCacheKey);
+}
+function peekPrefetchResponseForNavigation(rscUrl, interceptionContext = null, mountedSlotsHeader = null) {
+	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader);
+	if (!match) return null;
+	const { cacheKey, entry } = match;
+	if (entry.pending || entry.outcome !== "cache-seeded") return null;
+	if (entry.cacheForNavigation === false || !entry.snapshot) return null;
+	if (resolvePrefetchCacheEntryExpiresAt(entry) <= Date.now()) {
+		deletePrefetchCacheEntry(getPrefetchCache(), getPrefetchedUrls(), cacheKey, entry, true);
+		return null;
+	}
+	if (entry.expiresAt !== void 0 || entry.snapshot.expiresAt !== void 0) return {
+		...entry.snapshot,
+		expiresAt: resolvePrefetchCacheEntryExpiresAt(entry)
+	};
+	return entry.snapshot;
+}
 /**
 * Consume a prefetched response for a given rscUrl.
 * Only returns settled (non-pending) snapshots synchronously.
@@ -417,9 +611,12 @@ function consumePrefetchResponse(rscUrl, interceptionContext = null, mountedSlot
 	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader);
 	if (!match) return null;
 	const { cacheKey, entry } = match;
+	return consumeMatchedPrefetchResponse(cacheKey, entry, mountedSlotsHeader);
+}
+function consumeMatchedPrefetchResponse(cacheKey, entry, mountedSlotsHeader) {
 	if (entry.pending || entry.outcome !== "cache-seeded") return null;
 	if (entry.cacheForNavigation === false) return null;
-	deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, entry, false);
+	deletePrefetchCacheEntry(getPrefetchCache(), getPrefetchedUrls(), cacheKey, entry, false);
 	if (entry.snapshot) {
 		if (!isPrefetchCacheEntryCompatibleWithMountedSlots(entry, mountedSlotsHeader)) return null;
 		if (resolvePrefetchCacheEntryExpiresAt(entry) <= Date.now()) return null;
@@ -433,7 +630,7 @@ function consumePrefetchResponse(rscUrl, interceptionContext = null, mountedSlot
 }
 async function consumePrefetchResponseForNavigation(rscUrl, interceptionContext = null, mountedSlotsHeader = null, options) {
 	const cache = getPrefetchCache();
-	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader);
+	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, options?.additionalRscUrls);
 	if (!match) return null;
 	const { cacheKey, entry } = match;
 	if (entry.pending !== void 0) {
@@ -441,7 +638,7 @@ async function consumePrefetchResponseForNavigation(rscUrl, interceptionContext
 		if (cache.get(cacheKey) !== entry) return null;
 	}
 	if (options?.shouldConsume?.() === false) return null;
-	return consumePrefetchResponse(rscUrl, interceptionContext, mountedSlotsHeader);
+	return consumeMatchedPrefetchResponse(cacheKey, entry, mountedSlotsHeader);
 }
 const _CLIENT_NAV_STATE_KEY = Symbol.for("vinext.clientNavigationState");
 const _MOUNTED_SLOTS_HEADER_KEY = Symbol.for("vinext.mountedSlotsHeader");
@@ -772,7 +969,7 @@ function commitClientNavigationState(navId, options) {
 	if (isServer) return;
 	const state = getClientNavigationState();
 	if (!state) return;
-	if ((navId !== void 0 || options?.releaseSnapshot === true) && state.navigationSnapshotActiveCount > 0) state.navigationSnapshotActiveCount -= 1;
+	if ((options?.releaseSnapshot ?? navId !== void 0) && state.navigationSnapshotActiveCount > 0) state.navigationSnapshotActiveCount -= 1;
 	const urlChanged = syncCommittedUrlStateFromLocation();
 	let paramsChanged = false;
 	if (state.pendingClientParams !== null && state.pendingClientParamsJson !== null) {
@@ -1033,6 +1230,7 @@ const _appRouter = {
 	prefetch(href, options) {
 		assertSafeNavigationUrl(href);
 		if (isServer) return;
+		if (isBotUserAgent(window.navigator?.userAgent ?? "")) return;
 		try {
 			new URL(withBasePath(href, __basePath), window.location.href);
 		} catch {
@@ -1060,11 +1258,11 @@ const _appRouter = {
 				return;
 			}
 			prefetched.add(cacheKey);
-			prefetchRscResponse(rscUrl, fetch(rscUrl, {
+			prefetchRscResponse(rscUrl, scheduleAppPrefetchFetch(() => fetch(rscUrl, {
 				headers,
 				credentials: "include",
 				priority: "low"
-			}), interceptionContext, mountedSlotsHeader, options);
+			}), "low"), interceptionContext, mountedSlotsHeader, options);
 		})().catch((error) => {
 			console.error("[vinext] RSC prefetch setup error:", error);
 		});
@@ -1203,4 +1401,4 @@ if (!isServer) {
 	}
 }
 //#endregion
-export { BailoutToCSRError, 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, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getClientNavigationRenderContext, getClientNavigationState, getClientParams, getCurrentInterceptionContext, getCurrentNextUrl, getLayoutSegmentContext, getMountedSlotsHeader, getNavigationContext, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, navigateClientSide, notFound, permanentRedirect, prefetchRscResponse, pushHistoryStateWithoutNotify, redirect, renderServerInsertedHTML, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveCachedRscResponseExpiresAt, resolveCachedRscResponseTtlMs, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, 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, 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, pushHistoryStateWithoutNotify, redirect, renderServerInsertedHTML, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveCachedRscResponseExpiresAt, resolveCachedRscResponseTtlMs, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, seedPrefetchResponseSnapshot, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname, snapshotRscResponse, storePrefetchResponse, unauthorized, unstable_isUnrecognizedActionError, unstable_rethrow, useClientNavigationRenderSnapshot, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };

package/dist/shims/request-context.js

@@ -24,6 +24,24 @@ import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation }
 *   ctx?.waitUntil(somePromise);
 */
 const _als = getOrCreateAls("vinext.requestContext.als");
+const OPEN_NEXT_CLOUDFLARE_CONTEXT_SYMBOL = Symbol.for("__cloudflare-context__");
+let openNextCloudflareContextFallback;
+function installOpenNextCloudflareContextBridge() {
+	const descriptor = Object.getOwnPropertyDescriptor(globalThis, OPEN_NEXT_CLOUDFLARE_CONTEXT_SYMBOL);
+	if (descriptor && !descriptor.configurable) return;
+	openNextCloudflareContextFallback = descriptor && "value" in descriptor ? descriptor.value : descriptor?.get?.call(globalThis);
+	Object.defineProperty(globalThis, OPEN_NEXT_CLOUDFLARE_CONTEXT_SYMBOL, {
+		configurable: true,
+		get() {
+			const ctx = getRequestExecutionContext();
+			return ctx ? { ctx } : openNextCloudflareContextFallback;
+		},
+		set(value) {
+			openNextCloudflareContextFallback = value;
+		}
+	});
+}
+installOpenNextCloudflareContextBridge();
 function runWithExecutionContext(ctx, fn) {
 	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
 		uCtx.executionContext = ctx;

package/dist/shims/root-params.d.ts

@@ -3,10 +3,24 @@ type RootParams = Record<string, string | string[] | undefined>;
 type RootParamsState = {
   rootParams: RootParams | null;
 };
+type RootParamsUsage = {
+  kind: "route";
+} | {
+  kind: "server-action";
+} | {
+  kind: "route-handler";
+  routePattern: string;
+};
+type RootParamsUsageController = {
+  transitionToRender(): void;
+};
 declare function pickRootParams(params: RootParams, rootParamNames: readonly string[] | null | undefined): RootParams;
 declare function setRootParams(params: RootParams | null): void;
 declare function getRootParam(name: string): Promise<string | string[] | undefined>;
+declare function runWithRootParamsUsage<T>(usage: RootParamsUsage, fn: () => Promise<T>, controller?: RootParamsUsageController): Promise<T>;
+declare function runWithRootParamsUsage<T>(usage: RootParamsUsage, fn: () => T | Promise<T>, controller?: RootParamsUsageController): T | Promise<T>;
+declare function createRootParamsUsageController(): RootParamsUsageController;
 declare function runWithRootParamsScope<T>(params: RootParams, fn: () => Promise<T>): Promise<T>;
 declare function runWithRootParamsScope<T>(params: RootParams, fn: () => T | Promise<T>): T | Promise<T>;
 //#endregion
-export { RootParams, RootParamsState, getRootParam, pickRootParams, runWithRootParamsScope, setRootParams };
+export { RootParams, RootParamsState, RootParamsUsage, RootParamsUsageController, createRootParamsUsageController, getRootParam, pickRootParams, runWithRootParamsScope, runWithRootParamsUsage, setRootParams };

package/dist/shims/root-params.js

@@ -1,9 +1,13 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
 //#region src/shims/root-params.ts
+function createRootParamsUsageError(message) {
+	return new Error(message);
+}
 const _FALLBACK_KEY = Symbol.for("vinext.rootParams.fallback");
 const _g = globalThis;
 const _als = getOrCreateAls("vinext.rootParams.als");
+const _usageAls = getOrCreateAls("vinext.rootParams.usage.als");
 const _fallbackState = _g[_FALLBACK_KEY] ??= { rootParams: null };
 function getState() {
 	if (isInsideUnifiedScope()) return getRequestContext();
@@ -18,8 +22,24 @@ function setRootParams(params) {
 	getState().rootParams = params;
 }
 function getRootParam(name) {
+	const usage = _usageAls.getStore();
+	if (usage?.kind === "server-action" && usage.phase === "active") throw createRootParamsUsageError(`\`import('next/root-params').${name}()\` was used inside a Server Action. This is not supported. Functions from 'next/root-params' can only be called in the context of a route.`);
+	if (usage?.kind === "route-handler" && usage.phase === "active") throw createRootParamsUsageError(`Route ${usage.routePattern} used \`import('next/root-params').${name}()\` inside a Route Handler. Support for this API in Route Handlers is planned for a future version of Next.js.`);
 	return Promise.resolve(getState().rootParams?.[name]);
 }
+function runWithRootParamsUsage(usage, fn, controller) {
+	const state = {
+		...usage,
+		phase: "active"
+	};
+	if (controller) controller.transitionToRender = () => {
+		if (usage.kind === "server-action") state.phase = "render";
+	};
+	return _usageAls.run(state, fn);
+}
+function createRootParamsUsageController() {
+	return { transitionToRender() {} };
+}
 function runWithRootParamsScope(params, fn) {
 	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((ctx) => {
 		ctx.rootParams = params;
@@ -27,4 +47,4 @@ function runWithRootParamsScope(params, fn) {
 	else return _als.run({ rootParams: params }, fn);
 }
 //#endregion
-export { getRootParam, pickRootParams, runWithRootParamsScope, setRootParams };
+export { createRootParamsUsageController, getRootParam, pickRootParams, runWithRootParamsScope, runWithRootParamsUsage, setRootParams };

package/dist/shims/router.d.ts

@@ -1,4 +1,5 @@
 import { VinextNextData } from "../client/vinext-next-data.js";
+import { PagesRouterComponentsMap } from "./internal/pages-router-components.js";
 import { UrlQuery } from "../utils/query.js";
 import { ComponentType, ReactElement } from "react";
 
@@ -25,7 +26,7 @@ type NextRouter = {
   replace(url: string | UrlObject, as?: string, options?: TransitionOptions): Promise<boolean>; /** Go back */
   back(): void; /** Reload the page */
   reload(): void; /** Prefetch a page (injects <link rel="prefetch">) */
-  prefetch(url: string): Promise<void>; /** Register a callback to run before popstate navigation */
+  prefetch(url: string, as?: string): Promise<void>; /** Register a callback to run before popstate navigation */
   beforePopState(cb: BeforePopStateCallback): void; /** Listen for route changes */
   events: RouterEvents;
 };
@@ -174,16 +175,13 @@ type ExcludeRouterProps<P> = Pick<P, Exclude<keyof P, keyof WithRouterProps>>;
  */
 declare function withRouter<P extends WithRouterProps>(ComposedComponent: ComponentType<P>): ComponentType<ExcludeRouterProps<P>>;
 declare const RouterMethods: {
-  /** See `_components` comment above for the dual role this map plays. */components: {
-    [x: string]: {
-      __appRouter: true;
-    } | Record<string, unknown>;
-  };
+  /** See `_components` comment above for the dual role this map plays. */components: PagesRouterComponentsMap;
+  sdc: Record<string, Promise<Response>>;
   push: (url: string | UrlObject, as?: string, options?: TransitionOptions) => Promise<boolean>;
   replace: (url: string | UrlObject, as?: string, options?: TransitionOptions) => Promise<boolean>;
   back: () => void;
   reload: () => void;
-  prefetch: (url: string) => Promise<void>;
+  prefetch: (url: string, as?: string) => Promise<void>;
   beforePopState: (cb: BeforePopStateCallback) => void;
   events: RouterEvents;
 };