vinext 0.1.8 → 0.2.1

package/dist/shims/link.js

@@ -1,24 +1,19 @@
 "use client";
 import { stripBasePath } from "../utils/base-path.js";
 import { createRouteTrieCache, matchRouteWithTrie } from "../routing/route-matching.js";
-import { VINEXT_MOUNTED_SLOTS_HEADER } from "../server/headers.js";
 import { isDangerousScheme, reportBlockedDangerousNavigation } from "./url-safety.js";
-import { AppElementsWire } from "../server/app-elements-wire.js";
-import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "../server/app-rsc-render-mode.js";
-import "../server/app-elements.js";
 import { addLocalePrefix, getDomainLocaleUrl } from "../utils/domain-locale.js";
-import { prefetchPagesData, resolvePagesDataNavigationTarget } from "./internal/pages-data-target.js";
-import { appendSearchParamsToUrl, urlQueryToSearchParams } from "../utils/query.js";
-import { resolveHybridClientRouteOwner } from "./internal/hybrid-client-route-owner.js";
+import { getPagesMiddlewareDataHref, prefetchPagesData, resolvePagesDataNavigationTarget } from "./internal/pages-data-target.js";
 import { markAppRouteDetectedOnPrefetch } from "./internal/app-route-detection.js";
 import { isAbsoluteOrProtocolRelativeUrl, normalizePathTrailingSlash, toBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
+import { appendSearchParamsToUrl, urlQueryToSearchParams } from "../utils/query.js";
 import { interpolateDynamicRouteHref } from "./internal/interpolate-as.js";
 import { getCurrentBrowserLocale } from "./client-locale.js";
 import { getCurrentRoutePathnameForWarning } from "./internal/route-pattern-for-warning.js";
-import { createRscRequestHeaders, createRscRequestUrl, stripRscCacheBustingSearchParam, stripRscSuffix } from "../server/app-rsc-cache-busting.js";
+import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { getNavigationRuntime, hasAppNavigationRuntime, registerNavigationRuntimeFunctions } from "../client/navigation-runtime.js";
 import { navigatePagesRouterLinkWithFallback, resolvePagesRouterQueryOnlyHref } from "../client/pages-router-link-navigation.js";
-import { getMountedSlotsHeader, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, navigateClientSide, prefetchRscResponse } from "./navigation.js";
+import { scheduleAppPrefetchFetch } from "./internal/app-prefetch-fetch-queue.js";
 import { getI18nContext } from "./i18n-context.js";
 import { canLinkIntentPrefetch, canLinkPrefetch, getLinkPrefetchHref } from "./link-prefetch.js";
 import { clearLinkForCurrentNavigation, notifyLinkNavigationStart, setLinkForCurrentNavigation } from "./internal/link-status-registry.js";
@@ -144,7 +139,7 @@ function getLinkPrefetchRouterMode() {
 }
 function resolveMatchedAutoAppRoutePrefetch(route) {
 	return {
-		cacheForNavigation: !route.canPrefetchLoadingShell,
+		cacheForNavigation: !route.canPrefetchLoadingShell && route.requiresDynamicNavigationRequest !== true,
 		prefetchShellFirst: !route.isDynamic,
 		shouldPrefetch: true
 	};
@@ -155,9 +150,8 @@ function canAutoPrefetchFullAppRoute(href) {
 	if (!routes) return false;
 	const routeHref = toSameOriginRouteHref(href);
 	if (routeHref === null) return false;
-	const match = matchRouteWithTrie(routeHref, routes, linkPrefetchRouteTrieCache);
-	if (!match) return false;
-	return resolveMatchedAutoAppRoutePrefetch(match.route).cacheForNavigation;
+	if (!matchRouteWithTrie(routeHref, routes, linkPrefetchRouteTrieCache)) return false;
+	return resolveAutoAppRoutePrefetch(href).cacheForNavigation;
 }
 function resolveAutoAppRoutePrefetch(href) {
 	if (typeof window === "undefined") return {
@@ -183,19 +177,34 @@ function resolveAutoAppRoutePrefetch(href) {
 		prefetchShellFirst: false,
 		shouldPrefetch: false
 	};
-	return resolveMatchedAutoAppRoutePrefetch(match.route);
+	const prefetch = resolveMatchedAutoAppRoutePrefetch(match.route);
+	if (new URL(routeHref, "http://vinext.local").search !== "") return {
+		...prefetch,
+		cacheForNavigation: false,
+		prefetchShellFirst: true
+	};
+	return prefetch;
+}
+function resolveFullAppRoutePrefetch() {
+	return {
+		cacheForNavigation: true,
+		prefetchShellFirst: true,
+		shouldPrefetch: true
+	};
 }
 /**
 * Prefetch a URL for faster navigation.
 *
 * For App Router (RSC): fetches the .rsc payload in the background and
 * stores it in an in-memory cache for instant use during navigation.
-* For Pages Router: injects a <link rel="prefetch"> for the page module.
+* For Pages Router: warms the page chunk, prefetches data only for SSG pages,
+* and falls back to a document prefetch hint when no page loader matches.
 *
-* Uses `requestIdleCallback` (or `setTimeout` fallback) to avoid blocking
-* the main thread during initial page load.
+* App Router and high-priority prefetches start immediately. Low-priority
+* Pages Router fallback prefetches use `requestIdleCallback` (or `setTimeout`
+* fallback) to avoid blocking the main thread during initial page load.
 */
-function prefetchUrl(href, mode, priority = "low") {
+function prefetchUrl(href, mode, priority = "low", pagesRouteHref, locale) {
 	if (typeof window === "undefined") return;
 	const prefetchHref = getLinkPrefetchHref({
 		href,
@@ -204,31 +213,59 @@ function prefetchUrl(href, mode, priority = "low") {
 	});
 	if (prefetchHref == null) return;
 	const fullHref = toBrowserNavigationHref(prefetchHref, window.location.href, __basePath);
+	const fullRouteHref = toBrowserNavigationHref(pagesRouteHref === void 0 ? prefetchHref : getLinkPrefetchHref({
+		href: pagesRouteHref,
+		basePath: __basePath,
+		currentOrigin: window.location.origin
+	}) ?? prefetchHref, window.location.href, __basePath);
 	const target = new URL(fullHref, window.location.href);
 	if (target.origin === window.location.origin && target.pathname === window.location.pathname && target.search === window.location.search) return;
-	(priority === "high" ? (fn) => {
-		fn();
-	} : window.requestIdleCallback ?? ((fn) => setTimeout(fn, 100)))(() => {
+	const runPrefetch = () => {
 		(async () => {
 			if (hasAppNavigationRuntime()) {
+				if (isBotUserAgent(window.navigator?.userAgent ?? "")) return;
+				const [navigation, { AppElementsWire }, rscCacheBusting, { APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL }, headersModule, { resolveHybridClientRewriteHref, resolveHybridClientRouteOwner }] = await Promise.all([
+					import("./navigation.js"),
+					import("../server/app-elements.js"),
+					import("../server/app-rsc-cache-busting.js"),
+					import("../server/app-rsc-render-mode.js"),
+					import("../server/headers.js"),
+					import("./internal/hybrid-client-route-owner.js")
+				]);
+				const { getPrefetchInterceptionContext, getPrefetchCache, getPrefetchedUrls, getMountedSlotsHeader, hasSearchAgnosticPrefetchShellForRoute, hasPrefetchCacheEntryForNavigation, peekPrefetchResponseForNavigation, prefetchRscResponse, restoreRscResponse, PREFETCH_CACHE_TTL } = navigation;
+				const { createRscRequestHeaders, createRscRequestUrl } = rscCacheBusting;
+				const { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, VINEXT_MOUNTED_SLOTS_HEADER } = headersModule;
 				const hybridOwner = resolveHybridClientRouteOwner(prefetchHref, __basePath);
 				if (hybridOwner === "pages" || hybridOwner === "document") return;
-				const autoPrefetch = mode === "auto" ? resolveAutoAppRoutePrefetch(prefetchHref) : {
+				const rewrittenPrefetchHref = resolveHybridClientRewriteHref(fullHref, __basePath);
+				const autoPrefetch = mode === "auto" ? resolveAutoAppRoutePrefetch(rewrittenPrefetchHref ?? prefetchHref) : mode === "full-after-shell" ? {
 					cacheForNavigation: true,
 					prefetchShellFirst: true,
 					shouldPrefetch: true
-				};
+				} : resolveFullAppRoutePrefetch();
 				if (!autoPrefetch.shouldPrefetch) return;
 				const interceptionContext = getPrefetchInterceptionContext(fullHref);
 				const mountedSlotsHeader = getMountedSlotsHeader();
 				const isOptimisticRouteShellPrefetch = !autoPrefetch.cacheForNavigation;
+				const hasSearchParams = new URL(fullHref, window.location.href).search !== "";
+				const isAutomaticSearchParamShell = mode === "auto" && isOptimisticRouteShellPrefetch && hasSearchParams;
 				if (isOptimisticRouteShellPrefetch && interceptionContext !== null) return;
+				const hasSearchAgnosticShell = isAutomaticSearchParamShell && hasSearchAgnosticPrefetchShellForRoute(await createRscRequestUrl(fullHref, new Headers()), interceptionContext, mountedSlotsHeader);
 				const headers = createRscRequestHeaders({
 					interceptionContext,
-					renderMode: isOptimisticRouteShellPrefetch ? APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL : void 0
+					renderMode: isOptimisticRouteShellPrefetch ? hasSearchAgnosticShell ? APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL : isAutomaticSearchParamShell ? APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL : APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL : void 0
 				});
 				if (mountedSlotsHeader) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, mountedSlotsHeader);
+				const shouldSendSegmentPrefetchHeaders = isOptimisticRouteShellPrefetch || mode === "auto";
+				if (__prefetchInlining && autoPrefetch.cacheForNavigation) {
+					headers.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+					headers.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, "/__PAGE__");
+				} else if (shouldSendSegmentPrefetchHeaders) {
+					headers.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+					headers.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, "1");
+				}
 				const rscUrl = await createRscRequestUrl(fullHref, headers);
+				const additionalRscUrls = rewrittenPrefetchHref && rewrittenPrefetchHref !== fullHref ? [await createRscRequestUrl(rewrittenPrefetchHref, headers)] : [];
 				const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 				const prefetched = getPrefetchedUrls();
 				if (prefetched.has(cacheKey)) {
@@ -236,43 +273,130 @@ function prefetchUrl(href, mode, priority = "low") {
 					const existing = getPrefetchCache().get(cacheKey);
 					if (existing?.cacheForNavigation === false) existing.cacheForNavigation = true;
 				}
-				if (autoPrefetch.cacheForNavigation && hasPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader)) return;
-				prefetched.add(cacheKey);
-				prefetchRscResponse(rscUrl, __prefetchInlining && autoPrefetch.cacheForNavigation && autoPrefetch.prefetchShellFirst ? (async () => {
+				const fetchFullRscPayload = () => scheduleAppPrefetchFetch(() => fetch(rscUrl, {
+					headers,
+					credentials: "include",
+					priority,
+					purpose: "prefetch"
+				}), priority);
+				const fetchLoadingShellForReuse = async () => {
 					const shellHeaders = createRscRequestHeaders({
 						interceptionContext,
 						renderMode: APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL
 					});
+					shellHeaders.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+					shellHeaders.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, "1");
 					if (mountedSlotsHeader) shellHeaders.set(VINEXT_MOUNTED_SLOTS_HEADER, mountedSlotsHeader);
 					const shellRscUrl = await createRscRequestUrl(fullHref, shellHeaders);
-					const shellResponse = await fetch(shellRscUrl, {
-						headers: shellHeaders,
+					const shellCacheKey = AppElementsWire.encodeCacheKey(shellRscUrl, interceptionContext);
+					const shellCache = getPrefetchCache();
+					let shellEntry = shellCache.get(shellCacheKey);
+					if (shellEntry === void 0) {
+						getPrefetchedUrls().add(shellCacheKey);
+						prefetchRscResponse(shellRscUrl, scheduleAppPrefetchFetch(() => fetch(shellRscUrl, {
+							headers: shellHeaders,
+							credentials: "include",
+							priority,
+							purpose: "prefetch"
+						}), priority), interceptionContext, mountedSlotsHeader, void 0, {
+							cacheForNavigation: false,
+							optimisticRouteShell: true,
+							prefetchKind: "loading-shell"
+						});
+						shellEntry = shellCache.get(shellCacheKey);
+					}
+					await shellEntry?.pending?.catch(() => {});
+				};
+				const fetchAliasCacheHitProbe = async () => {
+					const probeHeaders = createRscRequestHeaders({
+						interceptionContext,
+						renderMode: APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL
+					});
+					probeHeaders.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+					probeHeaders.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, "1");
+					if (mountedSlotsHeader) probeHeaders.set(VINEXT_MOUNTED_SLOTS_HEADER, mountedSlotsHeader);
+					const probeRscUrl = await createRscRequestUrl(fullHref, probeHeaders);
+					return fetch(probeRscUrl, {
+						method: "HEAD",
+						headers: probeHeaders,
 						credentials: "include",
 						priority,
 						purpose: "prefetch"
 					});
-					if (!shellResponse.ok) return shellResponse;
-					await shellResponse.arrayBuffer().catch(() => {});
-					return fetch(rscUrl, {
+				};
+				const hasExactNavigationCacheEntry = autoPrefetch.cacheForNavigation && hasPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader);
+				if (hasExactNavigationCacheEntry || autoPrefetch.cacheForNavigation && hasPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, { additionalRscUrls })) {
+					if (!hasExactNavigationCacheEntry && !prefetched.has(cacheKey) && additionalRscUrls.length > 0 && autoPrefetch.prefetchShellFirst && mountedSlotsHeader === null) {
+						prefetched.add(cacheKey);
+						fetchAliasCacheHitProbe().then((response) => response.arrayBuffer()).catch(() => {});
+					}
+					return;
+				}
+				prefetched.add(cacheKey);
+				const gateViaRouteTree = __prefetchInlining && mode === "auto" && autoPrefetch.prefetchShellFirst;
+				const gateViaExplicitSearchShell = mode === "full" && hasSearchParams && autoPrefetch.prefetchShellFirst && mountedSlotsHeader === null;
+				const gateViaLoadingShell = (mode === "full-after-shell" || gateViaExplicitSearchShell) && autoPrefetch.prefetchShellFirst;
+				const fetchPromise = autoPrefetch.cacheForNavigation && (gateViaRouteTree || gateViaLoadingShell) ? (async () => {
+					if (gateViaLoadingShell) {
+						await fetchLoadingShellForReuse();
+						return fetchFullRscPayload();
+					}
+					const shellHeaders = createRscRequestHeaders({
+						interceptionContext,
+						renderMode: void 0
+					});
+					shellHeaders.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+					shellHeaders.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, "/_tree");
+					if (mountedSlotsHeader) shellHeaders.set(VINEXT_MOUNTED_SLOTS_HEADER, mountedSlotsHeader);
+					const shellRscUrl = await createRscRequestUrl(fullHref, shellHeaders);
+					const shellCacheKey = AppElementsWire.encodeCacheKey(shellRscUrl, interceptionContext);
+					const shellCache = getPrefetchCache();
+					let shellEntry = shellCache.get(shellCacheKey);
+					if (shellEntry === void 0) {
+						getPrefetchedUrls().add(shellCacheKey);
+						prefetchRscResponse(shellRscUrl, scheduleAppPrefetchFetch(() => fetch(shellRscUrl, {
+							headers: shellHeaders,
+							credentials: "include",
+							priority,
+							purpose: "prefetch"
+						}), priority), interceptionContext, mountedSlotsHeader, void 0, {
+							cacheForNavigation: false,
+							optimisticRouteShell: false,
+							prefetchKind: "route-tree"
+						});
+						shellEntry = shellCache.get(shellCacheKey);
+					}
+					await shellEntry?.pending?.catch(() => {});
+					const renderedPathAndSearch = shellEntry?.snapshot?.renderedPathAndSearch;
+					if (renderedPathAndSearch) {
+						const cachedRenderedResponse = peekPrefetchResponseForNavigation(await createRscRequestUrl(renderedPathAndSearch, headers), interceptionContext, mountedSlotsHeader);
+						if (cachedRenderedResponse) return restoreRscResponse(cachedRenderedResponse);
+					}
+					return scheduleAppPrefetchFetch(() => fetch(rscUrl, {
 						headers,
 						credentials: "include",
 						priority,
 						purpose: "prefetch"
-					});
-				})() : fetch(rscUrl, {
-					headers,
-					credentials: "include",
-					priority,
-					purpose: "prefetch"
-				}), interceptionContext, mountedSlotsHeader, void 0, {
+					}), priority);
+				})() : fetchFullRscPayload();
+				if (mode === "full" && autoPrefetch.cacheForNavigation && autoPrefetch.prefetchShellFirst && mountedSlotsHeader === null && !gateViaExplicitSearchShell) fetchLoadingShellForReuse();
+				prefetchRscResponse(rscUrl, fetchPromise, interceptionContext, mountedSlotsHeader, void 0, {
 					cacheForNavigation: autoPrefetch.cacheForNavigation,
-					optimisticRouteShell: isOptimisticRouteShellPrefetch
+					fallbackTtlMs: PREFETCH_CACHE_TTL,
+					optimisticRouteShell: isOptimisticRouteShellPrefetch,
+					prefetchKind: isOptimisticRouteShellPrefetch ? "loading-shell" : "navigation",
+					searchAgnosticShell: isAutomaticSearchParamShell && !hasSearchAgnosticShell
 				});
 			} else if (HAS_PAGES_ROUTER && window.__NEXT_DATA__) {
-				const dataTarget = resolvePagesDataNavigationTarget(fullHref, __basePath);
-				if (dataTarget) prefetchPagesData(dataTarget);
-				else {
-					markAppRouteDetectedOnPrefetch(fullHref, __basePath);
+				const dataTarget = resolvePagesDataNavigationTarget(fullRouteHref, __basePath, { locale });
+				if (dataTarget) {
+					const middlewareDataHref = fullRouteHref === fullHref ? dataTarget.middlewareDataHref : getPagesMiddlewareDataHref(fullHref, __basePath) ?? void 0;
+					prefetchPagesData({
+						...dataTarget,
+						middlewareDataHref
+					});
+				} else {
+					await markAppRouteDetectedOnPrefetch(fullHref, __basePath);
 					const link = document.createElement("link");
 					link.rel = "prefetch";
 					link.href = fullHref;
@@ -283,10 +407,17 @@ function prefetchUrl(href, mode, priority = "low") {
 		})().catch((error) => {
 			console.error("[vinext] RSC prefetch setup error:", error);
 		});
-	});
+	};
+	if (priority === "high" || hasAppNavigationRuntime()) {
+		runPrefetch();
+		return;
+	}
+	(window.requestIdleCallback ?? ((fn) => setTimeout(fn, 100)))(runPrefetch);
 }
-function promotePrefetchEntriesForNavigation(href) {
+async function promotePrefetchEntriesForNavigation(href) {
 	if (typeof window === "undefined") return;
+	if (!hasAppNavigationRuntime()) return;
+	const [{ getPrefetchCache }, { stripRscCacheBustingSearchParam, stripRscSuffix }] = await Promise.all([import("./navigation.js"), import("../server/app-rsc-cache-busting.js")]);
 	let target;
 	try {
 		target = new URL(toBrowserNavigationHref(href, window.location.href, __basePath), window.location.href);
@@ -295,6 +426,7 @@ function promotePrefetchEntriesForNavigation(href) {
 	}
 	for (const [cacheKey, entry] of getPrefetchCache()) {
 		if (entry.optimisticRouteShell === true) continue;
+		if (entry.prefetchKind === "route-tree") continue;
 		const [rscUrl] = cacheKey.split("\0", 1);
 		let cached;
 		try {
@@ -313,12 +445,33 @@ function promotePrefetchEntriesForNavigation(href) {
 let sharedObserver = null;
 const observedLinkPrefetches = /* @__PURE__ */ new WeakMap();
 const visibleLinkPrefetches = /* @__PURE__ */ new Set();
+const visibleAppPrefetchQueue = [];
+let visibleAppPrefetchDrainScheduled = false;
+function drainVisibleAppPrefetchQueue() {
+	visibleAppPrefetchDrainScheduled = false;
+	while (true) {
+		const instance = visibleAppPrefetchQueue.pop();
+		if (!instance) return;
+		instance.queuedViewportPrefetch = false;
+		if (!instance.isVisible || instance.routerMode !== "app") continue;
+		prefetchUrl(instance.href, instance.mode, "low", instance.pagesRouteHref);
+	}
+}
+function scheduleVisibleAppPrefetch(instance) {
+	if (instance.queuedViewportPrefetch) return;
+	instance.queuedViewportPrefetch = true;
+	visibleAppPrefetchQueue.push(instance);
+	if (visibleAppPrefetchDrainScheduled) return;
+	visibleAppPrefetchDrainScheduled = true;
+	queueMicrotask(drainVisibleAppPrefetchQueue);
+}
 function setVisibleLinkPrefetch(instance, isVisible) {
 	instance.isVisible = isVisible;
 	if (isVisible) {
 		visibleLinkPrefetches.add(instance);
 		if (instance.routerMode === "pages" && instance.viewportPrefetched) return;
-		prefetchUrl(instance.href, instance.mode, "low");
+		if (instance.routerMode === "app") scheduleVisibleAppPrefetch(instance);
+		else prefetchUrl(instance.href, instance.mode, "low", instance.pagesRouteHref, instance.locale);
 		instance.viewportPrefetched = true;
 	} else visibleLinkPrefetches.delete(instance);
 }
@@ -327,7 +480,7 @@ function registerVisibleLinkPing() {
 	registerNavigationRuntimeFunctions({ pingVisibleLinks: pingVisibleLinkPrefetches });
 }
 function pingVisibleLinkPrefetches() {
-	for (const instance of visibleLinkPrefetches) if (instance.isVisible && instance.routerMode === "app") prefetchUrl(instance.href, instance.mode, "low");
+	for (const instance of visibleLinkPrefetches) if (instance.isVisible && instance.routerMode === "app") scheduleVisibleAppPrefetch(instance);
 }
 function getSharedObserver() {
 	if (typeof window === "undefined" || typeof IntersectionObserver === "undefined") return null;
@@ -426,6 +579,7 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 	const resolvedHref = typeof rawResolvedHref === "string" ? warnAndNormalizeRepeatedSlashesInHref(rawResolvedHref) : rawResolvedHref;
 	const isDangerous = typeof resolvedHref === "string" && isDangerousScheme(resolvedHref);
 	const normalizedHref = normalizePathTrailingSlash(applyLocaleToHref(isDangerous ? "/" : resolvedHref, locale), __trailingSlash);
+	const normalizedRouteHref = HAS_PAGES_ROUTER && typeof as === "string" && typeof routeHrefRaw === "string" && as !== routeHrefRaw ? normalizePathTrailingSlash(applyLocaleToHref(isDangerous ? "/" : routeHrefRaw, locale), __trailingSlash) : normalizedHref;
 	const fullHref = normalizePathTrailingSlash(withBasePath(normalizedHref, __basePath), __trailingSlash);
 	const [pending, setPending] = useState(false);
 	const mountedRef = useRef(true);
@@ -469,7 +623,14 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 		const instance = {
 			href: hrefToPrefetch,
 			isVisible: false,
+			locale,
 			mode: prefetchMode,
+			pagesRouteHref: normalizedRouteHref === normalizedHref ? void 0 : getLinkPrefetchHref({
+				href: normalizedRouteHref,
+				basePath: __basePath,
+				currentOrigin: window.location.origin
+			}) ?? void 0,
+			queuedViewportPrefetch: false,
 			routerMode: getLinkPrefetchRouterMode(),
 			viewportPrefetched: false
 		};
@@ -479,11 +640,14 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 			observer.unobserve(node);
 			observedLinkPrefetches.delete(node);
 			visibleLinkPrefetches.delete(instance);
+			instance.isVisible = false;
 		};
 	}, [
 		shouldViewportPrefetch,
 		prefetchMode,
-		normalizedHref
+		normalizedHref,
+		normalizedRouteHref,
+		locale
 	]);
 	const prefetchOnIntent = useCallback(() => {
 		if (!canLinkIntentPrefetch({
@@ -492,18 +656,20 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 			isDangerous,
 			routerMode: getLinkPrefetchRouterMode()
 		})) return;
-		const intentMode = unstable_dynamicOnHover ? "full" : prefetchMode;
+		const intentMode = unstable_dynamicOnHover ? "full-after-shell" : prefetchMode;
 		if (unstable_dynamicOnHover && internalRef.current) {
 			const instance = observedLinkPrefetches.get(internalRef.current);
-			if (instance) instance.mode = "full";
+			if (instance) instance.mode = "full-after-shell";
 			promotePrefetchEntriesForNavigation(normalizedHref);
 		}
-		prefetchUrl(normalizedHref, intentMode, "high");
+		prefetchUrl(normalizedHref, intentMode, "high", normalizedRouteHref === normalizedHref ? void 0 : normalizedRouteHref, locale);
 	}, [
 		prefetchProp,
 		isDangerous,
 		prefetchMode,
 		normalizedHref,
+		normalizedRouteHref,
+		locale,
 		unstable_dynamicOnHover
 	]);
 	const handleMouseEnter = useCallback((e) => {
@@ -553,12 +719,14 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 			onNavigate(navEvent);
 			if (navEvent.defaultPrevented) return;
 		} catch {}
-		if (HAS_PAGES_ROUTER && hasAppNavigationRuntime && ["pages", "document"].includes(resolveHybridClientRouteOwner(navigateHref, __basePath) ?? "")) {
+		const hybridOwner = HAS_PAGES_ROUTER && hasAppNavigationRuntime ? (await import("./internal/hybrid-client-route-owner.js")).resolveHybridClientRouteOwner(navigateHref, __basePath) : null;
+		if (HAS_PAGES_ROUTER && hasAppNavigationRuntime && ["pages", "document"].includes(hybridOwner ?? "")) {
 			if (replace) window.location.replace(absoluteFullHref);
 			else window.location.assign(absoluteFullHref);
 			return;
 		}
 		if (hasAppNavigationRuntime) {
+			const { navigateClientSide } = await import("./navigation.js");
 			const setter = setPendingRef.current;
 			if (setter) setLinkForCurrentNavigation(setter);
 			setPending(true);
@@ -573,7 +741,7 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 			const Router = window.next?.appDir === true ? void 0 : window.next?.router;
 			await navigatePagesRouterLinkWithFallback({
 				router: Router && "reload" in Router ? Router : void 0,
-				loadRouter: async () => (await import("next/router.js")).default,
+				loadRouter: async () => (await import("next/router")).default,
 				navigation: {
 					href: pagesHrefForLink,
 					as: pagesAsForLink,
@@ -651,7 +819,7 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 			onClick: (event) => {
 				if (childOnClick) childOnClick(event);
 				if (event.defaultPrevented) return;
-				handleClick(event, { skipLinkOnClick: true });
+				return handleClick(event, { skipLinkOnClick: true });
 			},
 			onMouseEnter: (event) => {
 				if (childOnMouseEnter) childOnMouseEnter(event);
@@ -673,9 +841,7 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 		children: /* @__PURE__ */ jsx("a", {
 			ref: setRefs,
 			href: fullHref,
-			onClick: (event) => {
-				handleClick(event);
-			},
+			onClick: handleClick,
 			onMouseEnter: handleMouseEnter,
 			onTouchStart: handleTouchStart,
 			...anchorProps,

package/dist/shims/navigation.d.ts

@@ -10,8 +10,9 @@ import * as React$1 from "react";
 //#region src/shims/navigation.d.ts
 /** basePath from next.config.js, injected by the plugin at build time */
 declare const __basePath: string;
-/** Maximum number of entries in the RSC prefetch cache. */
-declare const MAX_PREFETCH_CACHE_SIZE = 50;
+/** Maximum buffered bytes in the RSC prefetch cache. Mirrors Next.js' 50 MB LRU. */
+declare const MAX_PREFETCH_CACHE_SIZE: number;
+declare const DYNAMIC_NAVIGATION_CACHE_TTL: number;
 declare const PREFETCH_CACHE_TTL: number;
 /** A buffered RSC response stored as an ArrayBuffer for replay. */
 type CachedRscResponse = {
@@ -22,12 +23,14 @@ type CachedRscResponse = {
   expiresAt?: number;
   mountedSlotsHeader?: string | null;
   paramsHeader: string | null;
+  renderedPathAndSearch: string | null;
   url: string;
 };
 type PrefetchOptions = {
   kind?: unknown;
   onInvalidate?: () => void;
 };
+type PrefetchCacheKind = "loading-shell" | "navigation" | "route-tree";
 type PrefetchCacheEntry = {
   cacheForNavigation?: boolean;
   expiresAt?: number;
@@ -37,7 +40,11 @@ type PrefetchCacheEntry = {
   optimisticRouteShell?: boolean;
   outcome: "pending" | "cache-seeded";
   snapshot?: CachedRscResponse;
+  cacheKeys?: Set<string>;
   pending?: Promise<void>;
+  prefetchKind?: PrefetchCacheKind;
+  searchAgnosticShell?: boolean;
+  size?: number;
   timestamp: number;
 };
 declare function getCurrentInterceptionContext(): string | null;
@@ -54,9 +61,13 @@ declare function resolveCachedRscResponseTtlMs(cached: Pick<CachedRscResponse, "
 declare function resolveCachedRscResponseExpiresAt(timestamp: number, cached: Pick<CachedRscResponse, "dynamicStaleTimeSeconds" | "expiresAt">, fallbackTtlMs: number): number;
 declare function resolvePrefetchCacheEntryMountedSlotsHeader(entry: PrefetchCacheEntry): string | null;
 declare function hasPrefetchCacheEntryForNavigation(rscUrl: string, interceptionContext?: string | null, mountedSlotsHeader?: string | null, options?: {
+  additionalRscUrls?: readonly string[];
   notifyInvalidation?: boolean;
 }): boolean;
+declare function hasSearchAgnosticPrefetchShellForRoute(rscUrl: string, interceptionContext?: string | null, mountedSlotsHeader?: string | null): boolean;
 declare function invalidatePrefetchCache(): void;
+declare function seedPrefetchResponseSnapshot(rscUrl: string, snapshot: CachedRscResponse, interceptionContext?: string | null, mountedSlotsHeader?: string | null, fallbackTtlMs?: number): void;
+declare function deletePrefetchResponseSnapshot(rscUrl: string, snapshot: CachedRscResponse, interceptionContext?: string | null): void;
 /**
  * Store a prefetched RSC response in the cache by snapshotting it to an
  * ArrayBuffer.  The snapshot completes asynchronously; during that window
@@ -105,8 +116,12 @@ declare function restoreRscResponse(cached: CachedRscResponse, copy?: boolean):
  */
 declare function prefetchRscResponse(rscUrl: string, fetchPromise: Promise<Response>, interceptionContext?: string | null, mountedSlotsHeader?: string | null, options?: PrefetchOptions, behavior?: {
   cacheForNavigation?: boolean;
+  fallbackTtlMs?: number;
   optimisticRouteShell?: boolean;
+  prefetchKind?: PrefetchCacheKind;
+  searchAgnosticShell?: boolean;
 }): void;
+declare function peekPrefetchResponseForNavigation(rscUrl: string, interceptionContext?: string | null, mountedSlotsHeader?: string | null): CachedRscResponse | null;
 /**
  * Consume a prefetched response for a given rscUrl.
  * Only returns settled (non-pending) snapshots synchronously.
@@ -121,6 +136,7 @@ declare function consumePrefetchResponse(rscUrl: string, interceptionContext?: s
  * one in-flight network request that navigation should share.
  */
 type ConsumePrefetchResponseForNavigationOptions = {
+  additionalRscUrls?: readonly string[];
   shouldConsume?: () => boolean;
 };
 declare function consumePrefetchResponseForNavigation(rscUrl: string, interceptionContext?: string | null, mountedSlotsHeader?: string | null, options?: ConsumePrefetchResponseForNavigationOptions): Promise<CachedRscResponse | null>;
@@ -283,4 +299,4 @@ declare function useSelectedLayoutSegments(parallelRoutesKey?: string): string[]
  */
 declare function useServerInsertedHTML(callback: () => unknown): void;
 //#endregion
-export { BailoutToCSRError, CachedRscResponse, ClientNavigationRenderSnapshot, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, MAX_PREFETCH_CACHE_SIZE, type NavigationContext, type NavigationStateAccessors, PREFETCH_CACHE_TTL, PrefetchCacheEntry, PrefetchOptions, ReadonlyURLSearchParams, RedirectType, type SegmentMap, 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, CachedRscResponse, ClientNavigationRenderSnapshot, DYNAMIC_NAVIGATION_CACHE_TTL, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, MAX_PREFETCH_CACHE_SIZE, type NavigationContext, type NavigationStateAccessors, PREFETCH_CACHE_TTL, PrefetchCacheEntry, PrefetchCacheKind, PrefetchOptions, ReadonlyURLSearchParams, RedirectType, type SegmentMap, 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 };