vinext 0.2.0 → 0.2.1

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 } 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";
@@ -12,7 +12,7 @@ import { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE,
 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";
@@ -23,6 +23,7 @@ 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
@@ -54,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.
 *
@@ -161,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 {
@@ -176,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,
@@ -201,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;
 	}
@@ -249,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);
@@ -295,19 +381,22 @@ function seedPrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext = nu
 	const cache = getPrefetchCache();
 	const existing = cache.get(cacheKey);
 	if (existing) deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, existing, false);
-	evictPrefetchCacheIfNeeded();
 	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);
@@ -334,27 +423,37 @@ function deletePrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext =
 */
 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));
@@ -365,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.
@@ -396,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
@@ -413,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);
+			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);
-		} else deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, false);
+			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";
@@ -438,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.
@@ -451,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;
@@ -467,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) {
@@ -475,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");
@@ -1095,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);
 		});
@@ -1238,4 +1401,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, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, decodeRedirectError, deletePrefetchResponseSnapshot, 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, 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, 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/navigation.react-server.js

@@ -1,8 +1,8 @@
 import { GLOBAL_ACCESSORS_KEY, ServerInsertedHTMLContext, _registerStateAccessors, clearServerInsertedHTML, flushServerInsertedHTML, getLayoutSegmentContext, getNavigationContext, renderServerInsertedHTML, setNavigationContext } from "./navigation-context-state.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 "./navigation-server.js";
-import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
 import { throwClientHookError } from "./client-hook-error.js";
+import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
 //#region src/shims/navigation.react-server.ts
 function usePathname() {
 	throwClientHookError("usePathname()");

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/router.js

@@ -22,7 +22,7 @@ import { scrollToHashTarget } from "./hash-scroll.js";
 import { installPagesRouterRuntime, setPagesRouterPopStateHandler, setStampInitialHistoryState } from "./pages-router-runtime.js";
 import { interpolateDynamicRouteHref } from "./internal/interpolate-as.js";
 import { getCurrentBrowserLocale } from "./client-locale.js";
-import { Component, Fragment, createElement, useContext, useEffect, useLayoutEffect, useMemo, useState } from "react";
+import { Component, Fragment, StrictMode, createElement, useContext, useEffect, useLayoutEffect, useMemo, useState } from "react";
 //#region src/shims/router.ts
 /**
 * next/router shim
@@ -1002,8 +1002,11 @@ async function resolveClientConfigRewrite(href) {
 		kind: "rewrite"
 	} : null;
 }
-function getMiddlewarePagesDataFetchUrl(browserUrl) {
-	return getPagesMiddlewareDataHref(browserUrl, __basePath);
+function getMiddlewarePagesDataFetchUrl(browserUrl, dataTarget) {
+	const middlewareDataHref = getPagesMiddlewareDataHref(browserUrl, __basePath);
+	if (!middlewareDataHref) return null;
+	if (dataTarget?.dataKind === "static" && dataTarget.middlewareDataHref === middlewareDataHref && dataTarget.prefetchDataHref) return dataTarget.prefetchDataHref;
+	return middlewareDataHref;
 }
 function getPagesDataCacheHref(dataHref) {
 	try {
@@ -1015,8 +1018,8 @@ function getPagesDataCacheHref(dataHref) {
 function shouldEvictMiddlewareDataCache(middlewareEffect, dataTarget) {
 	return middlewareEffect?.redirectLocation != null || dataTarget?.dataKind !== "static";
 }
-async function resolveMiddlewareDataEffect(browserUrl, signal) {
-	const dataUrl = getMiddlewarePagesDataFetchUrl(browserUrl);
+async function resolveMiddlewareDataEffect(browserUrl, signal, dataTarget) {
+	const dataUrl = getMiddlewarePagesDataFetchUrl(browserUrl, dataTarget);
 	if (!dataUrl) return null;
 	if (signal.aborted) throw new DOMException("Aborted", "AbortError");
 	try {
@@ -1209,14 +1212,18 @@ async function navigateClientData(url, initialTarget, controller, navId, assertS
 		await navigateClientHtml(redirectedUrl, redirectedUrl, controller, navId, assertStillCurrent);
 		return;
 	}
-	if (!res.ok) scheduleHardNavigationAndThrow(url, `Data navigation failed: ${res.status} ${res.statusText}`);
+	if (!res.ok) {
+		if (options.isHydrationQueryUpdate) return;
+		scheduleHardNavigationAndThrow(url, `Data navigation failed: ${res.status} ${res.statusText}`);
+	}
 	const rewriteTarget = res.headers.get("x-nextjs-rewrite");
-	const target = rewriteTarget ? resolvePagesDataNavigationTarget(rewriteTarget, __basePath) : initialTarget;
+	const target = rewriteTarget ? resolvePagesDataNavigationTarget(rewriteTarget, __basePath, { locale: initialTarget.prefetchLocale }) : initialTarget;
 	if (!target) scheduleHardNavigationAndThrow(url, "Data navigation failed: rewrite target has no page loader");
 	let body;
 	try {
 		body = await res.json();
 	} catch {
+		if (options.isHydrationQueryUpdate) return;
 		scheduleHardNavigationAndThrow(url, "Data navigation failed: invalid JSON response");
 	}
 	assertStillCurrent();
@@ -1382,20 +1389,21 @@ async function navigateClient(url, fetchUrl = url, options = {}, routeUrl = url)
 					htmlFetchUrl = configRewrite.href;
 				}
 			}
-			let dataTarget = resolvePagesDataNavigationTarget(routeLookupUrl, __basePath);
+			const pagesDataTargetOptions = { locale: options.locale };
+			let dataTarget = resolvePagesDataNavigationTarget(routeLookupUrl, __basePath, pagesDataTargetOptions);
 			let middlewareDataResponse;
 			let middlewareEffect = null;
 			let middlewareRewrittenTarget;
-			const middlewareProbeDataHref = getMiddlewarePagesDataFetchUrl(browserUrl);
+			const middlewareProbeDataHref = getMiddlewarePagesDataFetchUrl(browserUrl, dataTarget);
 			if (middlewareProbeDataHref !== null) {
 				middlewareDataCacheEvictHref = getPagesDataCacheHref(middlewareProbeDataHref);
 				try {
-					middlewareEffect = await resolveMiddlewareDataEffect(browserUrl, controller.signal);
+					middlewareEffect = await resolveMiddlewareDataEffect(browserUrl, controller.signal, dataTarget);
 				} catch (err) {
 					if (err instanceof DOMException && err.name === "AbortError") throw new NavigationCancelledError(browserUrl);
 					throw err;
 				}
-				if (middlewareEffect?.rewriteTarget) middlewareRewrittenTarget = resolvePagesDataNavigationTarget(middlewareEffect.rewriteTarget, __basePath);
+				if (middlewareEffect?.rewriteTarget) middlewareRewrittenTarget = resolvePagesDataNavigationTarget(middlewareEffect.rewriteTarget, __basePath, pagesDataTargetOptions);
 				if (middlewareEffect) if (shouldEvictMiddlewareDataCache(middlewareEffect, middlewareRewrittenTarget !== void 0 ? middlewareRewrittenTarget : dataTarget)) middlewareDataCacheEvictHref = middlewareEffect.dataHref;
 				else middlewareDataCacheEvictHref = null;
 				assertStillCurrent();
@@ -1412,7 +1420,9 @@ async function navigateClient(url, fetchUrl = url, options = {}, routeUrl = url)
 			} else if (middlewareEffect) {
 				if (middlewareEffect.rewriteTarget || routeUrl === url) middlewareDataResponse = middlewareEffect.response;
 				if (middlewareEffect.rewriteTarget) {
-					const rewrittenTarget = middlewareRewrittenTarget ?? resolvePagesDataNavigationTarget(middlewareEffect.rewriteTarget, __basePath);
+					const rewrittenOwner = resolveDirectHybridClientRouteOwner(middlewareEffect.rewriteTarget, __basePath);
+					if (rewrittenOwner === "app" || rewrittenOwner === "document") scheduleHardNavigationAndThrow(browserUrl, "Navigation rewritten to a non-Pages route");
+					const rewrittenTarget = middlewareRewrittenTarget ?? resolvePagesDataNavigationTarget(middlewareEffect.rewriteTarget, __basePath, pagesDataTargetOptions);
 					if (!rewrittenTarget) scheduleHardNavigationAndThrow(browserUrl, "Navigation rewritten to a non-Pages route");
 					dataTarget = rewrittenTarget;
 				}
@@ -1618,11 +1628,15 @@ async function performNavigation(url, as, options, mode, onStateUpdate) {
 	} : null;
 	const navigateOptions = errorRouteHtmlFetchUrl ? {
 		allowNotFoundResponse: true,
+		locale: navigationLocale,
 		mode,
-		scroll: scrollTarget
+		scroll: scrollTarget,
+		isHydrationQueryUpdate: options?._h === 1
 	} : {
+		locale: navigationLocale,
 		mode,
-		scroll: scrollTarget
+		scroll: scrollTarget,
+		isHydrationQueryUpdate: options?._h === 1
 	};
 	const currentLocale = getCurrentUrlLocale();
 	if (mode === "push" && interpolatedRoute !== resolved && stripHash(full) === routerRuntimeState.lastPathnameAndSearch && navigationLocale === currentLocale) mode = "replace";
@@ -1882,10 +1896,12 @@ setPagesRouterPopStateHandler(handlePagesRouterPopState);
 */
 function wrapWithRouterContext(element, onCommit = noopCommit, onError = noopCommit) {
 	const { CommitBoundary, Provider } = getPagesRouterRuntimeComponents();
+	let inner = createElement(Provider, null, element);
+	if (typeof window !== "undefined" && window.__VINEXT_REACT_STRICT_MODE__ === true) inner = createElement(StrictMode, null, inner);
 	return createElement(CommitBoundary, {
 		onCommit,
 		onError
-	}, createElement(Provider, null, element));
+	}, inner);
 }
 /**
 * Higher-order component that injects the Pages Router `router` instance as

package/dist/shims/unified-request-context.js

@@ -36,6 +36,7 @@ function createRequestContext(opts) {
 		currentFetchCacheMode: null,
 		currentForceDynamicFetchDefault: false,
 		dynamicFetchUrls: /* @__PURE__ */ new Set(),
+		refreshStaleFetchesInForeground: false,
 		isFetchDedupeActive: false,
 		currentFetchDedupeEntries: /* @__PURE__ */ new Map(),
 		executionContext: _getInheritedExecutionContext(),

package/dist/typegen.js

@@ -1,6 +1,6 @@
 import { findDir } from "./utils/project.js";
-import { decodeRouteSegment, isInvisibleSegment } from "./routing/utils.js";
 import { normalizePathSeparators } from "./utils/path.js";
+import { decodeRouteSegment, isInvisibleSegment } from "./routing/utils.js";
 import { patternToNextFormat } from "./routing/route-validation.js";
 import { compareStrings } from "./utils/compare.js";
 import "./routing/app-route-graph.js";

package/dist/utils/middleware-request-headers.js

@@ -59,7 +59,7 @@ function buildRequestHeadersFromMiddlewareResponse(baseHeaders, middlewareHeader
 	return nextHeaders;
 }
 function shouldKeepMiddlewareHeader(key) {
-	return key === "x-middleware-override-headers" || key === "x-middleware-set-cookie" || key.startsWith("x-middleware-request-");
+	return key === "x-middleware-override-headers" || key === "x-middleware-cache" || key === "x-middleware-set-cookie" || key.startsWith("x-middleware-request-");
 }
 //#endregion
 export { buildRequestHeadersFromMiddlewareResponse, encodeMiddlewareRequestHeaders, shouldKeepMiddlewareHeader };