vinext 1.2.1 → 1.3.1

package/dist/shims/image.js

@@ -1,7 +1,6 @@
 "use client";
-import { getDeploymentId } from "../utils/deployment-id.js";
 import { useMergedRef } from "./use-merged-ref.js";
-import { hasRemoteMatch, isPrivateIp } from "./image-config.js";
+import { RESPONSIVE_WIDTHS, __dangerouslyAllowSVG, __globallyUnoptimized, __isDev, generateImageAttributes, getFillStyle, getImageProps, imageOptimizationUrl, isRemoteUrl, isSvgUrl, resolveImageSource, sanitizeBlurDataURL, validateRemoteUrl } from "./image-props.js";
 import { forwardRef, useEffect, useLayoutEffect, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";
 import * as ReactDOM from "react-dom";
@@ -18,108 +17,11 @@ import { Image as Image$1 } from "@unpic/react";
 * Remote images are validated against `images.remotePatterns` and
 * `images.domains` from next.config.js. Unmatched URLs are blocked
 * in production and warn in development, matching Next.js behavior.
-*/
-/**
-* Image config injected at build time via Vite define.
-* Serialized as JSON — parsed once at module level.
-*/
-const __imageRemotePatterns = (() => {
-	try {
-		return JSON.parse(process.env.__VINEXT_IMAGE_REMOTE_PATTERNS ?? "[]");
-	} catch {
-		return [];
-	}
-})();
-const __imageDomains = (() => {
-	try {
-		return JSON.parse(process.env.__VINEXT_IMAGE_DOMAINS ?? "[]");
-	} catch {
-		return [];
-	}
-})();
-const __hasImageConfig = __imageRemotePatterns.length > 0 || __imageDomains.length > 0;
-const __isDev = process.env.NODE_ENV !== "production";
-const __imageDeviceSizes = (() => {
-	try {
-		return JSON.parse(process.env.__VINEXT_IMAGE_DEVICE_SIZES ?? "[640,750,828,1080,1200,1920,2048,3840]");
-	} catch {
-		return [
-			640,
-			750,
-			828,
-			1080,
-			1200,
-			1920,
-			2048,
-			3840
-		];
-	}
-})();
-const __imageSizes = (() => {
-	try {
-		return JSON.parse(process.env.__VINEXT_IMAGE_SIZES ?? "[32,48,64,96,128,256,384]");
-	} catch {
-		return [
-			32,
-			48,
-			64,
-			96,
-			128,
-			256,
-			384
-		];
-	}
-})();
-/**
-* Whether dangerouslyAllowSVG is enabled in next.config.js.
-* When false (default), .svg sources auto-skip the optimization endpoint
-* and are served directly, matching Next.js behavior.
-* When true, .svg sources are routed through the optimizer (served as-is
-* with security headers).
-*/
-const __dangerouslyAllowSVG = process.env.__VINEXT_IMAGE_DANGEROUSLY_ALLOW_SVG === "true";
-/**
-* Whether dangerouslyAllowLocalIP is enabled in next.config.js.
-* When false (default), remote image URLs with literal private-IP hostnames
-* are blocked to mitigate SSRF risk.
-*/
-const __dangerouslyAllowLocalIP = process.env.__VINEXT_IMAGE_DANGEROUSLY_ALLOW_LOCAL_IP === "true";
-const __globallyUnoptimized = process.env.__VINEXT_IMAGE_UNOPTIMIZED === "true";
-/**
-* Validate that a remote URL is allowed by the configured remote patterns.
-* Returns true if the URL is allowed, false otherwise.
-*
-* When no remotePatterns/domains are configured, all remote URLs are allowed
-* (backwards-compatible — user hasn't opted into restriction).
-*
-* When patterns ARE configured, only matching URLs are allowed.
-* In development, non-matching URLs produce a console warning.
-* In production, non-matching URLs are blocked (src replaced with empty string).
 *
-* Private-IP hostnames are additionally rejected unless dangerouslyAllowLocalIP
-* is set, mirroring Next.js's fetchExternalImage guard.
+* Prop building lives in the server-safe `image-props.ts`. In the RSC
+* environment, next/image resolves to a server entry that exports
+* `getImageProps` from there and this module's Image as a client reference.
 */
-function validateRemoteUrl(src) {
-	let url;
-	try {
-		url = new URL(src, "http://n");
-	} catch {
-		return {
-			allowed: false,
-			reason: `Invalid URL: ${src}`
-		};
-	}
-	if (!__dangerouslyAllowLocalIP && isPrivateIp(url.hostname)) return {
-		allowed: false,
-		reason: `Image URL "${src}" resolved to private IP. If this is expected and you understand SSRF risk, use images.dangerouslyAllowLocalIP = true to continue.`
-	};
-	if (!__hasImageConfig) return { allowed: true };
-	if (hasRemoteMatch(__imageDomains, __imageRemotePatterns, url)) return { allowed: true };
-	return {
-		allowed: false,
-		reason: `Image URL "${src}" is not configured in images.remotePatterns or images.domains in next.config.js. See: https://nextjs.org/docs/messages/next-image-unconfigured-host`
-	};
-}
 /**
 * A version of useLayoutEffect that doesn't warn during SSR.
 * Do not rename this to "isomorphic layout effect". There is no such thing as
@@ -167,110 +69,6 @@ function createSyntheticLoadEvent(img) {
 		}
 	};
 }
-/**
-* Sanitize a blurDataURL to prevent CSS injection.
-*
-* A crafted data URL containing `)` can break out of the `url()` CSS function,
-* allowing injection of arbitrary CSS properties or rules. Characters like `{`,
-* `}`, and `\` can also assist in crafting injection payloads.
-*
-* This validates the URL starts with `data:image/` and rejects characters that
-* could escape the `url()` context. Semicolons are allowed since they're part
-* of valid data URLs (`data:image/png;base64,...`) and harmless inside `url()`.
-*
-* Returns undefined for invalid URLs, which causes the blur placeholder to be
-* skipped gracefully.
-*/
-function sanitizeBlurDataURL(url) {
-	if (!url.startsWith("data:image/")) return void 0;
-	if (/[)(}{\\'"\n\r]/.test(url)) return void 0;
-	return url;
-}
-/**
-* Determine if a src is a remote URL (CDN-optimizable) or local.
-*/
-function isRemoteUrl(src) {
-	return src.startsWith("http://") || src.startsWith("https://") || src.startsWith("//");
-}
-function isSvgUrl(src) {
-	try {
-		return new URL(src, "http://vinext.local").pathname.toLowerCase().endsWith(".svg");
-	} catch {
-		return false;
-	}
-}
-function getFillStyle(style, backgroundStyle) {
-	return {
-		position: "absolute",
-		inset: 0,
-		width: "100%",
-		height: "100%",
-		objectFit: "cover",
-		...backgroundStyle,
-		...style
-	};
-}
-/**
-* Resolve src, width, height, blurDataURL from Image props (string or StaticImageData).
-* Shared by the Image component and getImageProps to keep behavior in sync.
-*/
-function resolveImageSource(v) {
-	const staticData = typeof v.src === "object" && "default" in v.src ? v.src.default : v.src;
-	const src = typeof staticData === "string" ? staticData : staticData.src;
-	const sourceWidth = v.width ?? (typeof staticData === "object" ? staticData.width : void 0);
-	const sourceHeight = v.height ?? (typeof staticData === "object" ? staticData.height : void 0);
-	return {
-		src,
-		width: typeof sourceWidth === "string" ? Number(sourceWidth) : sourceWidth,
-		height: typeof sourceHeight === "string" ? Number(sourceHeight) : sourceHeight,
-		blurDataURL: v.blurDataURL ?? (typeof staticData === "object" ? staticData.blurDataURL : void 0)
-	};
-}
-/**
-* Responsive image widths matching Next.js's device sizes config.
-* These are the breakpoints used for srcSet generation.
-* Configurable via `images.deviceSizes` in next.config.js.
-*/
-const RESPONSIVE_WIDTHS = [...__imageDeviceSizes].sort((left, right) => left - right);
-const ALL_IMAGE_WIDTHS = [...RESPONSIVE_WIDTHS, ...__imageSizes].sort((left, right) => left - right);
-function extractLocalDeploymentId(src) {
-	let deploymentId = getDeploymentId();
-	if (!src.startsWith("/") || src.startsWith("//")) return {
-		src,
-		deploymentId
-	};
-	const queryIndex = src.indexOf("?");
-	if (queryIndex === -1) return {
-		src,
-		deploymentId
-	};
-	const params = new URLSearchParams(src.slice(queryIndex + 1));
-	const sourceDeploymentId = params.get("dpl");
-	if (!sourceDeploymentId) return {
-		src,
-		deploymentId
-	};
-	deploymentId = sourceDeploymentId;
-	params.delete("dpl");
-	const remainingQuery = params.toString();
-	return {
-		src: src.slice(0, queryIndex) + (remainingQuery ? `?${remainingQuery}` : ""),
-		deploymentId
-	};
-}
-const __imageEndpoint = `${process.env.__NEXT_ROUTER_BASEPATH ?? ""}/_next/image${process.env.__VINEXT_TRAILING_SLASH === "true" ? "/" : ""}`;
-/**
-* Build a `/_next/image` optimization URL.
-*
-* In production (Cloudflare Workers), the worker intercepts this path and uses
-* the Images binding to resize/transcode on the fly. In dev, the Vite dev
-* server handles it as a passthrough (serves the original file).
-*/
-function imageOptimizationUrl(src, width, quality = 75) {
-	const source = extractLocalDeploymentId(src);
-	const deploymentQuery = source.src.startsWith("/") && source.deploymentId ? `&dpl=${source.deploymentId}` : "";
-	return `${__imageEndpoint}?url=${encodeURIComponent(source.src)}&w=${width}&q=${quality}${deploymentQuery}`;
-}
 function preloadImageResource(input) {
 	if (!input.shouldPreload) return;
 	if (typeof ReactDOM.preload !== "function") return;
@@ -281,31 +79,6 @@ function preloadImageResource(input) {
 		fetchPriority: input.fetchPriority
 	});
 }
-/**
-* Generate a srcSet string for responsive images.
-*
-* Each width points to the `/_next/image` optimization endpoint so the
-* server can resize and transcode the image.
-*/
-function getImageWidths(width) {
-	return [...new Set([width, width * 2].map((targetWidth) => ALL_IMAGE_WIDTHS.find((configuredWidth) => configuredWidth >= targetWidth) ?? ALL_IMAGE_WIDTHS[ALL_IMAGE_WIDTHS.length - 1]))];
-}
-function generateImageAttributes(src, width, quality = 75, sizes) {
-	if (sizes) {
-		const viewportPercentages = Array.from(sizes.matchAll(/(^|\s)(1?\d?\d)vw/g), (match) => Number.parseInt(match[2], 10));
-		const minimumWidth = viewportPercentages.length > 0 ? RESPONSIVE_WIDTHS[0] * (Math.min(...viewportPercentages) * .01) : 0;
-		const candidates = ALL_IMAGE_WIDTHS.filter((candidateWidth) => candidateWidth >= minimumWidth);
-		return {
-			src: imageOptimizationUrl(src, candidates[candidates.length - 1], quality),
-			srcSet: candidates.map((candidateWidth) => `${imageOptimizationUrl(src, candidateWidth, quality)} ${candidateWidth}w`).join(", ")
-		};
-	}
-	const widths = getImageWidths(width);
-	return {
-		src: imageOptimizationUrl(src, widths[widths.length - 1], quality),
-		srcSet: widths.map((candidateWidth, index) => `${imageOptimizationUrl(src, candidateWidth, quality)} ${index + 1}x`).join(", ")
-	};
-}
 const Image = forwardRef(function Image({ src: srcProp, alt, width, height, fill, preload, priority, quality, placeholder, blurDataURL, loader, sizes, className, style, onLoad, onLoadingComplete, onError, unoptimized: _unoptimized, overrideSrc, loading, ...rest }, ref) {
 	const lastLoadedSrcRef = useRef(void 0);
 	const lastErrorSrcRef = useRef(void 0);
@@ -562,93 +335,5 @@ const Image = forwardRef(function Image({ src: srcProp, alt, width, height, fill
 		...rest
 	});
 });
-/**
-* getImageProps — for advanced use cases (picture elements, background images).
-* Returns the props that would be passed to the underlying <img> element.
-*/
-function getImageProps(props) {
-	const { src: srcProp, alt, width, height, fill, preload: _preload, priority, quality: _quality, placeholder, blurDataURL: blurDataURLProp, loader, sizes, className, style, onLoad: _onLoad, onLoadingComplete: _onLoadingComplete, unoptimized: _unoptimized, overrideSrc, loading, ...rest } = props;
-	const { src, width: imgWidth, height: imgHeight, blurDataURL: imgBlurDataURL } = resolveImageSource({
-		src: srcProp,
-		width,
-		height,
-		blurDataURL: blurDataURLProp
-	});
-	const shouldPreload = _preload === true || priority === true;
-	if (_unoptimized === true || __globallyUnoptimized) {
-		const renderedSrc = overrideSrc || src;
-		const sanitizedBlurURL = imgBlurDataURL ? sanitizeBlurDataURL(imgBlurDataURL) : void 0;
-		const blurStyle = placeholder === "blur" && sanitizedBlurURL ? {
-			backgroundImage: `url(${sanitizedBlurURL})`,
-			backgroundSize: "cover",
-			backgroundRepeat: "no-repeat",
-			backgroundPosition: "center"
-		} : void 0;
-		const imageProps = {
-			src: renderedSrc,
-			alt,
-			width: fill ? void 0 : imgWidth,
-			height: fill ? void 0 : imgHeight,
-			loading: priority ? "eager" : shouldPreload ? loading : loading ?? "lazy",
-			fetchPriority: priority ? "high" : void 0,
-			decoding: "async",
-			className,
-			style: fill ? getFillStyle(style, blurStyle) : {
-				...blurStyle,
-				...style
-			},
-			...rest,
-			sizes: sizes ?? (fill ? "100vw" : void 0),
-			srcSet: void 0
-		};
-		return { props: Object.assign(imageProps, { "data-nimg": fill ? "fill" : "1" }) };
-	}
-	let blockedInProd = false;
-	if (isRemoteUrl(src)) {
-		const validation = validateRemoteUrl(src);
-		if (!validation.allowed) {
-			if (__isDev) console.warn(`[next/image] ${validation.reason}`);
-			else {
-				console.error(`[next/image] ${validation.reason}`);
-				blockedInProd = true;
-			}
-		}
-	}
-	const imgQuality = typeof _quality === "string" ? Number(_quality) : _quality ?? 75;
-	const resolvedSrc = blockedInProd ? "" : loader ? loader({
-		src,
-		width: imgWidth ?? 0,
-		quality: imgQuality
-	}) : src;
-	const skipOpt = isSvgUrl(resolvedSrc) && !__dangerouslyAllowSVG || blockedInProd || !!loader || isRemoteUrl(resolvedSrc);
-	const optimizedAttributes = imgWidth && !fill && !skipOpt ? generateImageAttributes(resolvedSrc, imgWidth, imgQuality, sizes) : null;
-	const optimizedSrc = skipOpt ? resolvedSrc : optimizedAttributes ? optimizedAttributes.src : imageOptimizationUrl(resolvedSrc, RESPONSIVE_WIDTHS[0], imgQuality);
-	const srcSet = optimizedAttributes?.srcSet;
-	const sanitizedBlurURL = imgBlurDataURL ? sanitizeBlurDataURL(imgBlurDataURL) : void 0;
-	const blurStyle = placeholder === "blur" && sanitizedBlurURL ? {
-		backgroundImage: `url(${sanitizedBlurURL})`,
-		backgroundSize: "cover",
-		backgroundRepeat: "no-repeat",
-		backgroundPosition: "center"
-	} : void 0;
-	const imageProps = {
-		src: optimizedSrc,
-		alt,
-		width: fill ? void 0 : imgWidth,
-		height: fill ? void 0 : imgHeight,
-		loading: priority ? "eager" : shouldPreload ? loading : loading ?? "lazy",
-		fetchPriority: priority ? "high" : void 0,
-		decoding: "async",
-		srcSet,
-		sizes: sizes ?? (fill ? "100vw" : void 0),
-		className,
-		style: fill ? getFillStyle(style, blurStyle) : {
-			...blurStyle,
-			...style
-		},
-		...rest
-	};
-	return { props: Object.assign(imageProps, { "data-nimg": fill ? "fill" : "1" }) };
-}
 //#endregion
 export { Image as default, getImageProps, imageOptimizationUrl };

package/dist/shims/internal/app-prefetch-fetch-queue.d.ts

@@ -4,8 +4,14 @@ export declare function releaseAppPrefetchFetchSlot(response: Response): void;
  * Low-priority App Router prefetches share a small request queue. The consumer
  * must either snapshot the returned Response with snapshotRscResponse() or call
  * releaseAppPrefetchFetchSlot() when it drops the response without consuming it.
+ *
+ * `isWanted` is checked when a queued request reaches a free slot. Returning
+ * false drops it without fetching, like a cancelled Next.js prefetch task. A
+ * navigation that promotes the request skips the check.
  */
-export declare function scheduleAppPrefetchFetch(fetcher: (signal: AbortSignal) => Promise<Response>, priority: "low" | "high"): Promise<Response>;
+export declare function scheduleAppPrefetchFetch(fetcher: (signal: AbortSignal) => Promise<Response>, priority: "low" | "high", isWanted?: () => boolean): Promise<Response>;
+/** Cancel a prefetch request that is still waiting for a slot; never aborts one in flight. */
+export declare function cancelQueuedAppPrefetchFetch(promise: Promise<Response>): void;
 /** Cancel a queued or in-flight prefetch request. No-op once it has settled. */
 export declare function cancelAppPrefetchFetch(promise: Promise<Response> | undefined): void;
 /**
@@ -19,6 +25,20 @@ export declare function cancelAppPrefetchFetch(promise: Promise<Response> | unde
  * cap instead of waiting for a slot.
  *
  * No-op when the request has already started or was never queued.
+ *
+ * Also records a claim, live while `isCurrent` returns true, until the returned
+ * function releases it; see `isAppPrefetchFetchClaimed`.
+ */
+export declare function promoteAppPrefetchFetch(promise: Promise<Response> | undefined, isCurrent?: () => boolean): () => void;
+/**
+ * Whether a current navigation is waiting on this prefetch. A staged prefetch
+ * (route tree, then payload) hands navigation a promise that wraps its queued
+ * requests, so promotion cannot reach them; they check this instead before
+ * dropping themselves.
+ *
+ * `claimedBy` limits this to claims made up to that `getAppPrefetchFetchClaimSequence()`.
  */
-export declare function promoteAppPrefetchFetch(promise: Promise<Response> | undefined): void;
+export declare function isAppPrefetchFetchClaimed(promise: Promise<Response> | undefined, claimedBy?: number): boolean;
+/** The sequence number of the latest claim on any prefetch. */
+export declare function getAppPrefetchFetchClaimSequence(): number;
 //#endregion

package/dist/shims/internal/app-prefetch-fetch-queue.js

@@ -5,6 +5,12 @@ const MAX_DEFAULT_APP_PREFETCH_REQUESTS = 4;
 const defaultAppPrefetchQueue = [];
 /** Lets a consumer promote or cancel the request behind a promise it already holds. */
 const appPrefetchFetchControls = /* @__PURE__ */ new WeakMap();
+/**
+* Navigations waiting on a promise, each live while it is current, with the
+* sequence number it was claimed at.
+*/
+const appPrefetchFetchClaims = /* @__PURE__ */ new WeakMap();
+let appPrefetchFetchClaimSequence = 0;
 let activeDefaultAppPrefetchRequests = 0;
 let defaultAppPrefetchDrainScheduled = false;
 function drainDefaultAppPrefetchQueue() {
@@ -31,8 +37,12 @@ function releaseAppPrefetchFetchSlot(response) {
 * Low-priority App Router prefetches share a small request queue. The consumer
 * must either snapshot the returned Response with snapshotRscResponse() or call
 * releaseAppPrefetchFetchSlot() when it drops the response without consuming it.
+*
+* `isWanted` is checked when a queued request reaches a free slot. Returning
+* false drops it without fetching, like a cancelled Next.js prefetch task. A
+* navigation that promotes the request skips the check.
 */
-function scheduleAppPrefetchFetch(fetcher, priority) {
+function scheduleAppPrefetchFetch(fetcher, priority, isWanted) {
 	const controller = new AbortController();
 	if (priority === "high") {
 		const promise = fetcher(controller.signal);
@@ -47,7 +57,13 @@ function scheduleAppPrefetchFetch(fetcher, priority) {
 	let started = false;
 	const promise = new Promise((resolve, reject) => {
 		rejectPromise = reject;
-		runner = () => {
+		runner = (promoted = false) => {
+			if (!promoted && isWanted?.() === false) {
+				appPrefetchFetchControls.delete(promise);
+				activeDefaultAppPrefetchRequests -= 1;
+				reject(new DOMException("Prefetch is no longer wanted", "AbortError"));
+				return;
+			}
 			started = true;
 			let didRelease = false;
 			const release = () => {
@@ -73,25 +89,31 @@ function scheduleAppPrefetchFetch(fetcher, priority) {
 			}
 		};
 	});
+	const cancelQueued = () => {
+		if (started) return;
+		const index = defaultAppPrefetchQueue.indexOf(runner);
+		if (index === -1) return;
+		defaultAppPrefetchQueue.splice(index, 1);
+		appPrefetchFetchControls.delete(promise);
+		controller.abort();
+		rejectPromise(controller.signal.reason);
+	};
 	defaultAppPrefetchQueue.push(runner);
 	appPrefetchFetchControls.set(promise, {
 		runner,
+		cancelQueued,
 		cancel: () => {
-			if (started) {
-				controller.abort();
-				return;
-			}
-			const index = defaultAppPrefetchQueue.indexOf(runner);
-			if (index === -1) return;
-			defaultAppPrefetchQueue.splice(index, 1);
-			appPrefetchFetchControls.delete(promise);
-			controller.abort();
-			rejectPromise(controller.signal.reason);
+			if (started) controller.abort();
+			else cancelQueued();
 		}
 	});
 	scheduleDefaultAppPrefetchDrain();
 	return promise;
 }
+/** Cancel a prefetch request that is still waiting for a slot; never aborts one in flight. */
+function cancelQueuedAppPrefetchFetch(promise) {
+	appPrefetchFetchControls.get(promise)?.cancelQueued?.();
+}
 /** Cancel a queued or in-flight prefetch request. No-op once it has settled. */
 function cancelAppPrefetchFetch(promise) {
 	if (promise === void 0) return;
@@ -108,16 +130,47 @@ function cancelAppPrefetchFetch(promise) {
 * cap instead of waiting for a slot.
 *
 * No-op when the request has already started or was never queued.
+*
+* Also records a claim, live while `isCurrent` returns true, until the returned
+* function releases it; see `isAppPrefetchFetchClaimed`.
 */
-function promoteAppPrefetchFetch(promise) {
-	if (promise === void 0) return;
+function promoteAppPrefetchFetch(promise, isCurrent = () => true) {
+	if (promise === void 0) return () => {};
+	let claims = appPrefetchFetchClaims.get(promise);
+	if (claims === void 0) {
+		claims = /* @__PURE__ */ new Map();
+		appPrefetchFetchClaims.set(promise, claims);
+	}
+	claims.set(isCurrent, ++appPrefetchFetchClaimSequence);
+	const release = () => {
+		claims.delete(isCurrent);
+	};
 	const runner = appPrefetchFetchControls.get(promise)?.runner;
-	if (runner === void 0) return;
+	if (runner === void 0) return release;
 	const index = defaultAppPrefetchQueue.indexOf(runner);
-	if (index === -1) return;
+	if (index === -1) return release;
 	defaultAppPrefetchQueue.splice(index, 1);
 	activeDefaultAppPrefetchRequests += 1;
-	runner();
+	runner(true);
+	return release;
+}
+/**
+* Whether a current navigation is waiting on this prefetch. A staged prefetch
+* (route tree, then payload) hands navigation a promise that wraps its queued
+* requests, so promotion cannot reach them; they check this instead before
+* dropping themselves.
+*
+* `claimedBy` limits this to claims made up to that `getAppPrefetchFetchClaimSequence()`.
+*/
+function isAppPrefetchFetchClaimed(promise, claimedBy = Infinity) {
+	const claims = promise && appPrefetchFetchClaims.get(promise);
+	if (!claims) return false;
+	for (const [isCurrent, sequence] of claims) if (sequence <= claimedBy && isCurrent()) return true;
+	return false;
+}
+/** The sequence number of the latest claim on any prefetch. */
+function getAppPrefetchFetchClaimSequence() {
+	return appPrefetchFetchClaimSequence;
 }
 //#endregion
-export { cancelAppPrefetchFetch, promoteAppPrefetchFetch, releaseAppPrefetchFetchSlot, scheduleAppPrefetchFetch };
+export { cancelAppPrefetchFetch, cancelQueuedAppPrefetchFetch, getAppPrefetchFetchClaimSequence, isAppPrefetchFetchClaimed, promoteAppPrefetchFetch, releaseAppPrefetchFetchSlot, scheduleAppPrefetchFetch };

package/dist/shims/internal/app-route-prefetch-policy.d.ts

@@ -16,16 +16,27 @@ export type AppRoutePrefetchPolicy = {
    * How the dynamic stale-time signal affects this prefetch. Navigation data
    * takes it verbatim, explicit full prefetches fall back to the static window
    * only when it is zero, and loading shells ignore it because their contents
-   * are static.
+   * are static. "learning-only" keeps a dynamic render out of navigation reuse
+   * and holds it for the static window instead.
    */
-  dynamicStaleTime: "verbatim" | "full-prefetch" | "ignore";
+  dynamicStaleTime: "verbatim" | "full-prefetch" | "ignore" | "learning-only";
   fallbackTtl: "dynamic" | "static";
   prefetchShellFirst: boolean;
+  /**
+   * The route renders dynamically (`rendersDynamically`), so the prefetch
+   * never renders its page: an href with search params fetches the loading
+   * shell instead of the page with empty search params.
+   */
+  rendersDynamically?: true;
   /** Fetch the route tree before the concrete page segment. */
   requiresRouteTreePrefetch?: true;
   shouldPrefetch: boolean;
 };
 export declare function canAutoPrefetchFullAppRoute(href: string): boolean;
-export declare function resolveAutoAppRoutePrefetch(href: string): AppRoutePrefetchPolicy;
+/**
+ * `interceptionContext` is the prefetch's interception context
+ * (`getPrefetchInterceptionContext`).
+ */
+export declare function resolveAutoAppRoutePrefetch(href: string, interceptionContext?: string | null): AppRoutePrefetchPolicy;
 export declare function resolveFullAppRoutePrefetch(): AppRoutePrefetchPolicy;
 //#endregion

package/dist/shims/internal/app-route-prefetch-policy.js

@@ -1,5 +1,7 @@
 import { stripBasePath } from "../../utils/base-path.js";
-import { createRouteTrieCache, matchRouteWithTrie } from "../../routing/route-matching.js";
+import { splitPathSegments } from "../../routing/utils.js";
+import { createRouteTrieCache, matchRouteWithTrie, matchRouteWithTrieRawPathname } from "../../routing/route-matching.js";
+import { matchRoutePatternPrefix, matchRoutePatternRaw } from "../../routing/route-pattern.js";
 //#region src/shims/internal/app-route-prefetch-policy.ts
 /** basePath from next.config.js, injected by the plugin at build time */
 const __basePath = process.env.__NEXT_ROUTER_BASEPATH ?? "";
@@ -27,7 +29,28 @@ const NO_APP_ROUTE_PREFETCH = {
 function canAutoPrefetchFullAppRoute(href) {
 	return resolveAutoAppRoutePrefetch(href).cacheForNavigation;
 }
-function resolveAutoAppRoutePrefetch(href) {
+/**
+* Whether the page the href renders is dynamic. Under an interception context
+* that one of the route's intercepting pages matches, that page renders
+* instead, and Next.js classifies it as its own route. When several match,
+* any dynamic one counts. The intercepted response also renders the route the
+* context resolves to, which can be a dynamic descendant of the intercept's
+* source, so that route counts too.
+*/
+function resolveRendersDynamically(routes, route, interceptionContext, pathname) {
+	if (interceptionContext !== null && route.intercepts) {
+		const pathParts = splitPathSegments(pathname);
+		const contextParts = splitPathSegments(interceptionContext);
+		const matching = route.intercepts.filter((intercept) => matchRoutePatternRaw(pathParts, intercept.targetPatternParts) !== null && matchRoutePatternPrefix(contextParts, intercept.sourcePatternParts));
+		if (matching.length > 0) return matching.some((intercept) => intercept.rendersDynamically === true) || matchRouteWithTrieRawPathname(interceptionContext, routes, linkPrefetchRouteTrieCache)?.route.rendersDynamically === true;
+	}
+	return route.rendersDynamically === true;
+}
+/**
+* `interceptionContext` is the prefetch's interception context
+* (`getPrefetchInterceptionContext`).
+*/
+function resolveAutoAppRoutePrefetch(href, interceptionContext = null) {
 	if (typeof window === "undefined") return NO_APP_ROUTE_PREFETCH;
 	const routes = window.__VINEXT_LINK_PREFETCH_ROUTES__;
 	if (!routes) return NO_APP_ROUTE_PREFETCH;
@@ -42,12 +65,14 @@ function resolveAutoAppRoutePrefetch(href) {
 	const hasSearchParams = routeUrl.search !== "";
 	const isFullyDynamicRootRoute = route.patternParts.length === 1 && route.patternParts[0]?.startsWith(":");
 	const hasCacheComponentsLearningOnlyDynamicPath = route.isDynamic && String(process.env.__NEXT_CACHE_COMPONENTS) === "true" && (ENCODED_PATH_DELIMITER_RE.test(routeUrl.pathname) || isFullyDynamicRootRoute && !requiresRouteTreePrefetch);
-	const cacheForNavigation = !hasSearchParams && !hasCacheComponentsLearningOnlyDynamicPath && (requiresRouteTreePrefetch || !route.canPrefetchLoadingShell && route.requiresDynamicNavigationRequest !== true);
+	const rendersDynamically = resolveRendersDynamically(routes, route, interceptionContext, routeUrl.pathname);
+	const cacheForNavigation = !hasSearchParams && !hasCacheComponentsLearningOnlyDynamicPath && (requiresRouteTreePrefetch || !route.canPrefetchLoadingShell && route.requiresDynamicNavigationRequest !== true && !rendersDynamically);
 	return {
 		cacheForNavigation,
-		dynamicStaleTime: cacheForNavigation ? "verbatim" : "ignore",
+		dynamicStaleTime: !cacheForNavigation ? "ignore" : String(process.env.__NEXT_CACHE_COMPONENTS) === "true" ? "verbatim" : "learning-only",
 		fallbackTtl: "static",
 		prefetchShellFirst: requiresRouteTreePrefetch || hasSearchParams || !route.isDynamic,
+		...rendersDynamically ? { rendersDynamically: true } : {},
 		...requiresRouteTreePrefetch ? { requiresRouteTreePrefetch: true } : {},
 		shouldPrefetch: true
 	};

package/dist/shims/internal/cache-context-accessor.d.ts

@@ -13,4 +13,5 @@ export declare function _registerCacheContextAccessor(fn: () => CacheContextLike
 export declare function getRegisteredCacheContext(): CacheContextLike | null;
 /** Record a root-param dependency on the active public `"use cache"` scope. */
 export declare function _recordUseCacheRootParamRead(name: string): void;
-//#endregion
+//#endregion
+export {};

package/dist/shims/internal/client-reference-loader.d.ts

@@ -0,0 +1,7 @@
+//#region src/shims/internal/client-reference-loader.d.ts
+type ClientReferenceExports = Record<string, unknown>;
+export declare function registerClientReference(key: string, exports: ClientReferenceExports): void;
+/** What @vitejs/plugin-rsc/browser calls as `clientReferences.default[key]()`. */
+export declare const clientReferences: Record<string, () => Promise<ClientReferenceExports>>;
+//#endregion
+export {};