vinext 1.3.0 → 1.4.0

package/dist/shims/font-utils.js

@@ -92,15 +92,17 @@ function formatFontClassRule(className, style) {
 	].join("; ")}; }\n`;
 }
 /**
-* Determine the MIME type for a font file based on its extension.
+* Determine the preload `type` for a font file based on its extension.
 * Uses endsWith() only to avoid false positives from substring matches
-* (e.g. ".woff" matching ".woff2").
+* (e.g. ".woff" matching ".woff2"). Matches Next.js, which emits
+* `font/${ext}` for every font preload (including `font/eot`).
 */
 function getFontMimeType(pathOrUrl) {
 	if (pathOrUrl.endsWith(".woff2")) return "font/woff2";
 	if (pathOrUrl.endsWith(".woff")) return "font/woff";
 	if (pathOrUrl.endsWith(".ttf")) return "font/ttf";
-	if (pathOrUrl.endsWith(".otf")) return "font/opentype";
+	if (pathOrUrl.endsWith(".otf")) return "font/otf";
+	if (pathOrUrl.endsWith(".eot")) return "font/eot";
 	return "font/woff2";
 }
 //#endregion

package/dist/shims/form.js

@@ -5,10 +5,10 @@ import "../server/headers.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "../server/app-rsc-render-mode.js";
 import { withBasePath } from "./url-utils.js";
-import { AppElementsWire } from "../server/app-elements-wire.js";
-import "../server/app-elements.js";
 import { createRscRequestHeaders, createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
 import { hasAppNavigationRuntime, loadNavigationRuntimeRouteManifest } from "../client/navigation-runtime.js";
+import { AppElementsWire } from "../server/app-elements-wire.js";
+import "../server/app-elements.js";
 import { getMountedSlotsHeader, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, navigateClientSide, prefetchRscResponse } from "./navigation.js";
 import { useMergedRef } from "./use-merged-ref.js";
 import { forwardRef, useActionState, useCallback, useEffect, useRef } from "react";
@@ -161,7 +161,7 @@ const Form = forwardRef(function Form(props, ref) {
 					const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 					const prefetched = getPrefetchedUrls();
 					if (prefetched.has(cacheKey)) return;
-					if (hasPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader)) return;
+					if (hasPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, { reusePending: false })) return;
 					prefetched.add(cacheKey);
 					const fetchPromise = fetch(rscUrl, {
 						headers,

package/dist/shims/headers.d.ts

@@ -1,5 +1,4 @@
 import { RenderRequestApiKind } from "../server/cache-proof.js";
-import { CacheLifeConfig } from "./cache-request-state.js";
 import { ConnectionProbeResult, HeadersAccessPhase, RenderDynamicLatch, VinextHeadersShimState, createRenderDynamicLatch, getHeadersAccessPhase, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, throwIfInsideCacheScope, throwIfStaticGenerationAccessError } from "./internal/headers-state.js";
 import { ReadonlyRequestCookies } from "@vinext/types/next/upstream/dist/server/web/spec-extension/adapters/request-cookies";
 import { ResponseCookie } from "@vinext/types/next/upstream/dist/compiled/@edge-runtime/cookies/index";
@@ -19,27 +18,11 @@ type HeadersContextFromRequestOptions = {
   draftModeSecret?: string;
 };
 /**
- * Measure dynamic usage in a child async scope without clearing the parent.
- * Concurrent work that already belongs to the request (such as deferred
- * metadata) keeps writing to the parent state and therefore remains visible
- * to the final cache policy.
- */
-export declare function runWithIsolatedDynamicUsage<T>(fn: () => T | Promise<T>): Promise<{
-  result: T;
-  dynamicDetected: boolean;
-}>;
-/**
- * Run a pre-render probe without letting its dynamic API usage classify the
- * request. Next.js has no probe: only the render decides whether a page is
- * dynamic, and the render runs the probed layouts and page again. Returns the
- * probe's own usage and cacheLife for a caller whose probe response replaces
- * the render.
- */
-export declare function runWithDetachedDynamicUsage<T>(fn: () => T | Promise<T>): Promise<{
-  result: T;
-  dynamicDetected: boolean;
-  cacheLife: CacheLifeConfig | null;
-}>;
+ * Run a layout probe without letting its dynamic API usage, fetch tags or
+ * cacheLife reach the request. Next.js has no probe: only the render decides
+ * whether a page is dynamic and how long it is cached.
+ */
+export declare function runWithDetachedDynamicUsage<T>(fn: () => T | Promise<T>): Promise<T>;
 export declare function runWithConnectionProbe<T>(fn: () => T | Promise<T>): Promise<ConnectionProbeResult<T>>;
 export declare function suspendConnectionProbe(): Promise<never> | null;
 export declare function peekRenderRequestApiUsage(): RenderRequestApiKind[];
@@ -214,7 +197,9 @@ declare class RequestCookies {
   private _cookies;
   private _responseCookies;
   constructor(cookies: Map<string, string>, mutable?: boolean);
-  get(name: string): ResponseCookie | undefined;
+  get(nameOrOptions: string | {
+    name: string;
+  }): ResponseCookie | undefined;
   getAll(nameOrOptions?: string | {
     name: string;
   }): ResponseCookie[];

package/dist/shims/headers.js

@@ -84,78 +84,27 @@ function mergeMiddlewareSetCookies(ctx, rawHeader) {
 	return merged;
 }
 /**
-* Measure dynamic usage in a child async scope without clearing the parent.
-* Concurrent work that already belongs to the request (such as deferred
-* metadata) keeps writing to the parent state and therefore remains visible
-* to the final cache policy.
-*/
-async function runWithIsolatedDynamicUsage(fn) {
-	const runInChildState = async (childState) => {
-		return {
-			result: await fn(),
-			dynamicDetected: childState.dynamicUsageDetected
-		};
-	};
-	if (isInsideUnifiedScope()) {
-		let childState = null;
-		return await runWithUnifiedStateMutation((context) => {
-			context.dynamicUsageDetected = false;
-			childState = context;
-		}, () => {
-			if (!childState) throw new Error("Dynamic usage scope was not initialized");
-			return runInChildState(childState);
-		});
-	}
-	const parentState = getHeadersShimState();
-	const childState = {
-		...parentState,
-		renderDynamicLatch: ensureRenderDynamicLatch(parentState),
-		dynamicUsageDetected: false
-	};
-	return await headersShimAls.run(childState, () => runInChildState(childState));
-}
-/**
-* Run a pre-render probe without letting its dynamic API usage classify the
-* request. Next.js has no probe: only the render decides whether a page is
-* dynamic, and the render runs the probed layouts and page again. Returns the
-* probe's own usage and cacheLife for a caller whose probe response replaces
-* the render.
+* Run a layout probe without letting its dynamic API usage, fetch tags or
+* cacheLife reach the request. Next.js has no probe: only the render decides
+* whether a page is dynamic and how long it is cached.
 */
 async function runWithDetachedDynamicUsage(fn) {
-	const runInChildState = async (childState, cacheLifeSink) => {
-		return {
-			result: await fn(),
-			cacheLife: cacheLifeSink?.cacheLife ?? null,
-			dynamicDetected: childState.dynamicUsageDetected || childState.renderDynamicLatch.dynamic
-		};
-	};
-	if (isInsideUnifiedScope()) {
-		let childState = null;
-		const cacheLifeSink = { cacheLife: null };
-		return await runWithUnifiedStateMutation((context) => {
-			context.cacheLifeSink = cacheLifeSink;
-			context.dynamicUsageDetected = false;
-			context.renderDynamicLatch = createRenderDynamicLatch();
-			context.renderRequestApiUsage = /* @__PURE__ */ new Set();
-			context.requestCache = /* @__PURE__ */ new WeakMap();
-			context.cacheableFetchUrls = /* @__PURE__ */ new Set();
-			context.currentRequestTags = [];
-			context.dynamicFetchUrls = /* @__PURE__ */ new Set();
-			context.requestScopedCacheLife = null;
-			context.unstableCacheObservations = /* @__PURE__ */ new Map();
-			childState = context;
-		}, () => {
-			if (!childState) throw new Error("Dynamic usage scope was not initialized");
-			return runInChildState(childState, cacheLifeSink);
-		});
-	}
+	if (isInsideUnifiedScope()) return await runWithUnifiedStateMutation((context) => {
+		context.dynamicUsageDetected = false;
+		context.renderDynamicLatch = createRenderDynamicLatch();
+		context.renderRequestApiUsage = /* @__PURE__ */ new Set();
+		context.requestCache = /* @__PURE__ */ new WeakMap();
+		context.currentRequestTags = [];
+		context.dynamicFetchUrls = /* @__PURE__ */ new Set();
+		context.requestScopedCacheLife = null;
+	}, fn);
 	const childState = {
 		...getHeadersShimState(),
 		dynamicUsageDetected: false,
 		renderDynamicLatch: createRenderDynamicLatch(),
 		renderRequestApiUsage: /* @__PURE__ */ new Set()
 	};
-	return await headersShimAls.run(childState, () => runInChildState(childState, null));
+	return await headersShimAls.run(childState, fn);
 }
 async function runWithConnectionProbe(fn) {
 	const parentState = getHeadersShimState();
@@ -513,7 +462,7 @@ function _wrapMutableCookies(cookies) {
 }
 function _sealCookies(cookies) {
 	return new Proxy(cookies, { get(target, prop) {
-		if (prop === "set" || prop === "delete") throw new ReadonlyRequestCookiesError();
+		if (prop === "set" || prop === "delete" || prop === "clear") return ReadonlyRequestCookiesError.callable;
 		const value = Reflect.get(target, prop, target);
 		return typeof value === "function" ? value.bind(target) : value;
 	} });
@@ -761,7 +710,8 @@ var RequestCookies = class {
 			value
 		})])) : null;
 	}
-	get(name) {
+	get(nameOrOptions) {
+		const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions.name;
 		if (this._responseCookies) return this._responseCookies.get(name);
 		const value = this._cookies.get(name);
 		if (value === void 0) return void 0;
@@ -877,4 +827,4 @@ function serializeMutableCookie(cookie) {
 	});
 }
 //#endregion
-export { applyEffectiveRequestCookieHeader, applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, createRenderDynamicLatch, draftMode, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, getEffectiveRequestCookieHeader, getHeadersAccessPhase, getHeadersContext, hasDraftModeCookieHeader, hasEffectiveRequestCookieChanges, headers, headersContextFromRequest, isDraftModeEnabled, isDraftModeRequest, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, peekDynamicUsage, peekRenderRequestApiUsage, replaceHeadersContext, restoreDraftModeTransition, runWithConnectionProbe, runWithDetachedDynamicUsage, runWithHeadersContext, runWithIsolatedDynamicUsage, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };
+export { applyEffectiveRequestCookieHeader, applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, createRenderDynamicLatch, draftMode, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, getEffectiveRequestCookieHeader, getHeadersAccessPhase, getHeadersContext, hasDraftModeCookieHeader, hasEffectiveRequestCookieChanges, headers, headersContextFromRequest, isDraftModeEnabled, isDraftModeRequest, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, peekDynamicUsage, peekRenderRequestApiUsage, replaceHeadersContext, restoreDraftModeTransition, runWithConnectionProbe, runWithDetachedDynamicUsage, runWithHeadersContext, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };

package/dist/shims/http-access-error-fallback.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+//#region src/shims/http-access-error-fallback.d.ts
+export declare function HTTPAccessErrorFallback({ status, message }: {
+  status: number;
+  message: string;
+}): React.ReactElement;
+//#endregion

package/dist/shims/http-access-error-fallback.js

@@ -0,0 +1,47 @@
+import React from "react";
+//#region src/shims/http-access-error-fallback.tsx
+/**
+* Ported from Next.js's built-in HTTP access fallback UI:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/http-access-fallback/error-fallback.tsx
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/styles/access-error-styles.ts
+*
+* Shared by the built-in not-found, forbidden and unauthorized pages: a
+* centered status / message pair with minified theme CSS and dark-mode media
+* query. Kept in sync with the upstream component's structure so HTML
+* snapshot diffs between Next.js and vinext stay minimal.
+*/
+const styles = {
+	error: {
+		fontFamily: "system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"",
+		height: "100vh",
+		textAlign: "center",
+		display: "flex",
+		flexDirection: "column",
+		alignItems: "center",
+		justifyContent: "center"
+	},
+	desc: { display: "inline-block" },
+	h1: {
+		display: "inline-block",
+		margin: "0 20px 0 0",
+		padding: "0 23px 0 0",
+		fontSize: 24,
+		fontWeight: 500,
+		verticalAlign: "top",
+		lineHeight: "49px"
+	},
+	h2: {
+		fontSize: 14,
+		fontWeight: 400,
+		lineHeight: "49px",
+		margin: 0
+	}
+};
+function HTTPAccessErrorFallback({ status, message }) {
+	return React.createElement(React.Fragment, null, React.createElement("title", null, `${status}: ${message}`), React.createElement("div", { style: styles.error }, React.createElement("div", null, React.createElement("style", { dangerouslySetInnerHTML: { __html: "body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}" } }), React.createElement("h1", {
+		className: "next-error-h1",
+		style: styles.h1
+	}, status), React.createElement("div", { style: styles.desc }, React.createElement("h2", { style: styles.h2 }, message)))));
+}
+//#endregion
+export { HTTPAccessErrorFallback };

package/dist/shims/image.d.ts

@@ -4,27 +4,6 @@ import { ImageLoader, ImageProps as ImageProps$1, StaticImageData, StaticRequire
 //#region src/shims/image.d.ts
 export type ImageLoaderProps = Parameters<ImageLoader>[0];
 export type ImageProps = ImageProps$1;
-declare const Image: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "alt" | "height" | "loading" | "ref" | "src" | "srcSet" | "width"> & {
-  src: string | import("@vinext/types/next/upstream/dist/shared/lib/get-img-props").StaticImport;
-  alt: string;
-  width?: number | `${number}`;
-  height?: number | `${number}`;
-  fill?: boolean;
-  loader?: ImageLoader;
-  quality?: number | `${number}`;
-  preload?: boolean;
-  priority?: boolean;
-  loading?: "eager" | "lazy" | undefined;
-  placeholder?: import("@vinext/types/next/upstream/dist/shared/lib/get-img-props").PlaceholderValue;
-  blurDataURL?: string;
-  unoptimized?: boolean;
-  overrideSrc?: string;
-  onLoadingComplete?: import("@vinext/types/next/upstream/dist/shared/lib/get-img-props").OnLoadingComplete;
-  layout?: string;
-  objectFit?: string;
-  objectPosition?: string;
-  lazyBoundary?: string;
-  lazyRoot?: string;
-} & React.RefAttributes<HTMLImageElement>>;
+declare const Image: React.ForwardRefExoticComponent<ImageProps & React.RefAttributes<HTMLImageElement>>;
 //#endregion
 export { type ImageLoader, type StaticImageData, type StaticRequire, 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 {};