vinext 1.3.1 → 1.4.1

package/dist/shims/dynamic.js

@@ -89,9 +89,11 @@ function createElementWithProps(Component, props) {
 }
 /**
 * Lightweight error boundary that renders the loading component with the error
-* when a dynamic() loader rejects. Without this, loader failures would propagate
-* uncaught through React's rendering — this preserves the Next.js behavior where
-* the `loading` component can display errors.
+* when a dynamic() loader rejects, as the Pages Router's react-loadable does by
+* passing `error` to `loading`. App Router trees never get it: Next.js's App
+* Router next/dynamic is React.lazy inside Suspense with no boundary of its own,
+* so loader and render errors reach the nearest error.tsx.
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/lazy-dynamic/loadable.tsx
 *
 * Lazily created because React.Component is not available in the RSC environment
 * (server components use a slimmed-down React that doesn't include class components).
@@ -202,6 +204,7 @@ function dynamic(dynamicInput, options) {
 		}
 		const InitialLazyComponent = createLazyComponent(loader);
 		const ClientSSRFalse = (props) => {
+			const isAppRouterTree = useIsAppRouterTree();
 			const [mounted, setMounted] = React.useState(false);
 			const { LazyComponent, retry, retryKey } = useRetryableLazyComponent(loader, InitialLazyComponent);
 			React.useEffect(() => setMounted(true), []);
@@ -209,7 +212,7 @@ function dynamic(dynamicInput, options) {
 			const fallback = LoadingComponent ? React.createElement(LoadingComponent, createDynamicLoadingProps({ retry })) : null;
 			const lazyElement = createElementWithProps(LazyComponent, props);
 			let content = lazyElement;
-			if (LoadingComponent) {
+			if (LoadingComponent && !isAppRouterTree) {
 				const ErrorBoundary = getDynamicErrorBoundary();
 				if (ErrorBoundary) content = React.createElement(ErrorBoundary, {
 					fallback: LoadingComponent,
@@ -237,7 +240,7 @@ function dynamic(dynamicInput, options) {
 			const fallback = LoadingComponent ? React.createElement(LoadingComponent, createDynamicLoadingProps()) : null;
 			const lazyElement = createElementWithProps(LazyServer, props);
 			let content = lazyElement;
-			if (LoadingComponent) {
+			if (LoadingComponent && !isAppRouterTree) {
 				const ErrorBoundary = getDynamicErrorBoundary();
 				if (ErrorBoundary) content = React.createElement(ErrorBoundary, {
 					fallback: LoadingComponent,
@@ -257,7 +260,7 @@ function dynamic(dynamicInput, options) {
 		const fallback = LoadingComponent ? React.createElement(LoadingComponent, createDynamicLoadingProps({ retry })) : null;
 		const lazyElement = createElementWithProps(LazyComponent, props);
 		let content = lazyElement;
-		if (LoadingComponent) {
+		if (LoadingComponent && !isAppRouterTree) {
 			const ErrorBoundary = getDynamicErrorBoundary();
 			if (ErrorBoundary) content = React.createElement(ErrorBoundary, {
 				fallback: LoadingComponent,

package/dist/shims/error-boundary.js

@@ -1,11 +1,11 @@
 "use client";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
+import { handleAppNavigationFailure } from "../client/app-nav-failure-handler.js";
+import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
 import { decodeRedirectError, forbidden, isRedirectError, notFound, unauthorized } from "./navigation-errors.js";
 import "./navigation-server.js";
 import { isRedirectToCurrentUrl, useErrorBoundaryPathname, useErrorBoundaryRouter } from "./error-boundary-navigation.js";
 import DefaultGlobalError from "./default-global-error.js";
-import { handleAppNavigationFailure } from "../client/app-nav-failure-handler.js";
-import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
 import { consumeCaughtNotFoundBoundary, useCaughtNotFoundBoundary } from "./caught-not-found-boundaries.js";
 import React from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";

package/dist/shims/fetch-cache-state.d.ts

@@ -11,12 +11,16 @@ export type FetchDedupeEntry = {
   response: Response | null;
 };
 export type FetchCacheState = {
-  cacheableFetchUrls: Set<string>;
   currentRequestTags: string[];
   currentFetchSoftTags: string[];
   currentFetchCacheMode: FetchCacheMode | null;
   currentFetchRevalidate: number | null;
   currentForceDynamicFetchDefault: boolean;
+  /**
+   * Pages Router preview/draft render. App Router draft state is read from the
+   * headers context instead; Pages renders don't have one.
+   */
+  isDraftMode: boolean;
   dynamicFetchUrls: Set<string>;
   refreshStaleFetchesInForeground: boolean;
   isFetchDedupeActive: boolean;

package/dist/shims/fetch-cache-state.js

@@ -11,12 +11,12 @@ const _FALLBACK_KEY = Symbol.for("vinext.fetchCache.fallback");
 const fetchCacheAls = getOrCreateAls("vinext.fetchCache.als");
 function createFetchCacheState() {
 	return {
-		cacheableFetchUrls: /* @__PURE__ */ new Set(),
 		currentRequestTags: [],
 		currentFetchSoftTags: [],
 		currentFetchCacheMode: null,
 		currentFetchRevalidate: null,
 		currentForceDynamicFetchDefault: false,
+		isDraftMode: false,
 		dynamicFetchUrls: /* @__PURE__ */ new Set(),
 		refreshStaleFetchesInForeground: false,
 		isFetchDedupeActive: false,
@@ -77,13 +77,11 @@ function getCurrentFetchSoftTags() {
 */
 function runWithDetachedFetchObservations(fn) {
 	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
-		uCtx.cacheableFetchUrls = /* @__PURE__ */ new Set();
 		uCtx.currentRequestTags = [];
 		uCtx.dynamicFetchUrls = /* @__PURE__ */ new Set();
 	}, fn);
 	return fetchCacheAls.run({
 		...getFetchCacheState(),
-		cacheableFetchUrls: /* @__PURE__ */ new Set(),
 		currentRequestTags: [],
 		dynamicFetchUrls: /* @__PURE__ */ new Set()
 	}, fn);

package/dist/shims/fetch-cache.d.ts

@@ -11,7 +11,6 @@ declare global {
 }
 /** @internal Reset dedup state — exposed for test isolation only. */
 export declare function _resetPendingRefetches(): void;
-export declare function peekCacheableFetchObservations(): string[];
 export declare function peekDynamicFetchObservations(): string[];
 export declare function consumeDynamicFetchObservations(): string[];
 /**
@@ -31,6 +30,8 @@ export declare function setCurrentFetchSoftTags(tags: string[]): void;
 export declare function setCurrentFetchCacheMode(mode: FetchCacheMode | null): void;
 export declare function setCurrentFetchRevalidate(revalidate: number | null): void;
 export declare function setCurrentForceDynamicFetchDefault(enabled: boolean): void;
+/** Mark the current Pages Router render as a preview/draft render. */
+export declare function setCurrentFetchDraftMode(enabled: boolean): void;
 export declare function setRefreshStaleFetchesInForeground(enabled: boolean): void;
 /**
  * Install the patched fetch and reset per-request tag state.

package/dist/shims/fetch-cache.js

@@ -6,8 +6,8 @@ import { sha256Hex } from "../utils/hash.js";
 import { traceAppFetch } from "../server/app-fetch-tracing.js";
 import { addCollectedRequestTags, fallbackFetchCacheState, fetchCacheAls, getCurrentFetchSoftTags, getFetchCacheState, resetFallbackFetchCacheState, runWithDetachedFetchObservations } from "./fetch-cache-state.js";
 import { isInsideAnyCacheScope, markDynamicUsage } from "./internal/headers-state.js";
-import { getHeadersContext } from "./headers.js";
-import { _hasPendingRevalidatedTag, _setRequestScopedCacheLife } from "./cache-request-state.js";
+import { getHeadersContext, isDraftModeEnabled } from "./headers.js";
+import { _hasPendingRevalidatedTag, _isOnDemandRevalidate, _setRequestScopedCacheLife } from "./cache-request-state.js";
 import { Buffer } from "node:buffer";
 //#region src/shims/fetch-cache.ts
 /**
@@ -463,9 +463,6 @@ function markUncachedFetchForPageOutput(input) {
 	if (getHeadersContext()?.forceStatic !== true) getFetchCacheState().currentFetchRevalidate = 0;
 	markDynamicUsage();
 }
-function recordCacheableFetchObservation(input) {
-	getFetchCacheState().cacheableFetchUrls.add(getFetchObservationUrl(input));
-}
 function recordFiniteFetchRevalidate(revalidateSeconds) {
 	if (Number.isFinite(revalidateSeconds) && revalidateSeconds > 0) _setRequestScopedCacheLife({ revalidate: revalidateSeconds });
 }
@@ -503,7 +500,8 @@ async function writeFetchCacheResponse(handler, cacheKey, response, tags, revali
 	await handler.set(cacheKey, cacheValue, {
 		fetchCache: true,
 		tags,
-		revalidate: revalidateSeconds
+		revalidate: revalidateSeconds,
+		...options?.staleEntry ? { staleEntry: options.staleEntry } : {}
 	});
 }
 async function lowerFetchCacheRevalidateIfNeeded(handler, cacheKey, cachedValue, tags, revalidateSeconds) {
@@ -520,9 +518,6 @@ async function lowerFetchCacheRevalidateIfNeeded(handler, cacheKey, cachedValue,
 		revalidate: revalidateSeconds
 	});
 }
-function peekCacheableFetchObservations() {
-	return [...getFetchCacheState().cacheableFetchUrls].sort();
-}
 function peekDynamicFetchObservations() {
 	return [...getFetchCacheState().dynamicFetchUrls].sort();
 }
@@ -559,6 +554,10 @@ function setCurrentFetchRevalidate(revalidate) {
 function setCurrentForceDynamicFetchDefault(enabled) {
 	getFetchCacheState().currentForceDynamicFetchDefault = enabled;
 }
+/** Mark the current Pages Router render as a preview/draft render. */
+function setCurrentFetchDraftMode(enabled) {
+	getFetchCacheState().isDraftMode = enabled;
+}
 function setRefreshStaleFetchesInForeground(enabled) {
 	getFetchCacheState().refreshStaleFetchesInForeground = enabled;
 }
@@ -705,8 +704,12 @@ function dedupeFetch(input, init) {
 */
 function createPatchedFetch() {
 	const patchedFetch = async function patchedFetch(input, init, span) {
-		const nextOpts = init?.next;
 		const state = getFetchCacheState();
+		if (state.isDraftMode || isDraftModeEnabled()) {
+			recordDynamicFetchObservation(input);
+			return dedupeFetch(input, init);
+		}
+		const nextOpts = init?.next;
 		const fetchIdx = isInsideUnifiedScope() || fetchCacheAls.getStore() !== void 0 || fallbackFetchCacheState.isFetchDedupeActive ? (state.nextFetchId ?? 1) + 1 : void 0;
 		if (fetchIdx !== void 0) state.nextFetchId = fetchIdx;
 		const recordFetchOutcome = (response, cacheStatus, cacheReason) => {
@@ -753,7 +756,6 @@ function createPatchedFetch() {
 			return recordFetchOutcome(await dedupeFetch(input, cleanInit), "skip", "auto no cache");
 		}
 		const cacheReason = fetchCacheMode === "force-cache" || fetchCacheMode === "default-cache" ? `fetchCache = ${fetchCacheMode}` : `revalidate: ${nextOpts?.revalidate === false || cacheDirective === "force-cache" ? 4294967294 : revalidateSeconds}`;
-		recordCacheableFetchObservation(input);
 		if (typeof nextOpts?.revalidate === "number" && nextOpts.revalidate > 0) {
 			lowerCurrentFetchRevalidate(nextOpts.revalidate);
 			recordFiniteFetchRevalidate(nextOpts.revalidate);
@@ -785,8 +787,9 @@ function createPatchedFetch() {
 		}
 		const handler = getDataCacheHandler();
 		let mustBypassPendingRevalidation = _hasPendingRevalidatedTag([...tags, ...softTags]);
+		let staleEntry;
 		try {
-			let cached = mustBypassPendingRevalidation ? null : await handler.get(cacheKey, {
+			let cached = mustBypassPendingRevalidation || _isOnDemandRevalidate() ? null : await handler.get(cacheKey, {
 				kind: "FETCH",
 				tags,
 				softTags,
@@ -801,20 +804,28 @@ function createPatchedFetch() {
 				cached = null;
 			}
 			if (cached?.value && cached.value.kind === "FETCH" && cached.cacheState !== "stale") {
-				await lowerFetchCacheRevalidateIfNeeded(handler, cacheKey, cached.value, tags, revalidateSeconds);
+				await lowerFetchCacheRevalidateIfNeeded(handler, cacheKey, cached.value, tags, revalidateSeconds).catch((err) => {
+					console.error("[vinext] fetch cache write error:", err);
+				});
 				const cachedData = cached.value.data;
 				return recordFetchOutcome(buildCachedFetchResponse(cachedData, input), "hit", cacheReason);
 			}
 			if (cached?.value && cached.value.kind === "FETCH" && cached.cacheState === "stale") {
+				staleEntry = cached;
 				if (shouldRefreshStaleFetchInForeground()) {
 					const freshResponse = await dedupeFetch(input, fetchInit);
-					await writeFetchCacheResponse(handler, cacheKey, freshResponse, tags, revalidateSeconds);
+					await writeFetchCacheResponse(handler, cacheKey, freshResponse, tags, revalidateSeconds, { staleEntry: cached }).catch((err) => {
+						console.error("[vinext] fetch cache write error:", err);
+					});
 					return recordFetchOutcome(freshResponse, "miss", cacheReason);
 				}
 				const staleData = cached.value.data;
 				if (!pendingRefetches.has(cacheKey)) {
 					const refetchPromise = originalFetch(input, fetchInit).then(async (freshResp) => {
-						await writeFetchCacheResponse(handler, cacheKey, freshResp, tags, revalidateSeconds, { cloneForReturn: false });
+						await writeFetchCacheResponse(handler, cacheKey, freshResp, tags, revalidateSeconds, {
+							cloneForReturn: false,
+							staleEntry: cached
+						});
 					}).catch((err) => {
 						const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
 						console.error(`[vinext] fetch cache background revalidation failed for ${url} (key=${cacheKey.slice(0, 12)}...):`, err);
@@ -835,13 +846,17 @@ function createPatchedFetch() {
 		}
 		const response = await (mustBypassPendingRevalidation ? originalFetch(input, fetchInit) : dedupeFetch(input, fetchInit));
 		const cacheValue = await buildFetchCacheValue(response, tags, revalidateSeconds);
-		if (cacheValue) handler.set(cacheKey, cacheValue, {
-			fetchCache: true,
-			tags,
-			revalidate: revalidateSeconds
-		}).catch((err) => {
-			console.error("[vinext] fetch cache write error:", err);
-		});
+		if (cacheValue) {
+			const write = handler.set(cacheKey, cacheValue, {
+				fetchCache: true,
+				tags,
+				revalidate: revalidateSeconds,
+				...staleEntry ? { staleEntry } : {}
+			}).catch((err) => {
+				console.error("[vinext] fetch cache write error:", err);
+			});
+			getRequestExecutionContext()?.waitUntil(write);
+		}
 		return recordFetchOutcome(response, "miss", cacheReason);
 	};
 	return ((input, init) => {
@@ -894,7 +909,6 @@ function withFetchCache() {
 async function runWithFetchCache(fn) {
 	_ensurePatchInstalled();
 	if (isInsideUnifiedScope()) return await runWithUnifiedStateMutation((uCtx) => {
-		uCtx.cacheableFetchUrls = /* @__PURE__ */ new Set();
 		uCtx.currentRequestTags = [];
 		uCtx.currentFetchSoftTags = [];
 		uCtx.dynamicFetchUrls = /* @__PURE__ */ new Set();
@@ -904,12 +918,12 @@ async function runWithFetchCache(fn) {
 		uCtx.nextFetchId = 1;
 	}, fn);
 	return fetchCacheAls.run({
-		cacheableFetchUrls: /* @__PURE__ */ new Set(),
 		currentRequestTags: [],
 		currentFetchSoftTags: [],
 		currentFetchCacheMode: null,
 		currentFetchRevalidate: null,
 		currentForceDynamicFetchDefault: false,
+		isDraftMode: false,
 		dynamicFetchUrls: /* @__PURE__ */ new Set(),
 		refreshStaleFetchesInForeground: false,
 		isFetchDedupeActive: true,
@@ -950,4 +964,4 @@ function getOriginalFetch() {
 	return originalFetch;
 }
 //#endregion
-export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithDetachedFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };
+export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekDynamicFetchObservations, runWithDetachedFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchDraftMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };

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";

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[];
@@ -185,7 +168,8 @@ export declare function getActiveDraftModeState(): boolean | null;
 /**
  * Read the active request's draft-mode state without recording request API usage.
  * Internal cache implementations use this to bypass persistent reads and writes,
- * matching Next.js's request-level `workStore.isDraftMode` guard.
+ * matching Next.js's request-level `workStore.isDraftMode` guard. Once the
+ * headers context is cleared, the request keeps the state it had then.
  */
 export declare function isDraftModeEnabled(): boolean;
 type DraftModeResult = {
@@ -214,7 +198,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

@@ -1,4 +1,4 @@
-import { ensureRenderDynamicLatch, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
+import { ensureRenderDynamicLatch, getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
 import { MIDDLEWARE_SET_COOKIE_HEADER } from "../utils/protocol-headers.js";
 import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
 import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.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();
@@ -343,6 +292,7 @@ function setHeadersContext(ctx) {
 		state.draftModeCookieHeader = null;
 		state.phase = "render";
 	} else {
+		if (state.headersContext && isInsideUnifiedScope()) getRequestContext().draftModeAtHeadersClear = getActiveDraftModeState() === true;
 		state.headersContext = null;
 		state.phase = "render";
 	}
@@ -513,7 +463,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;
 	} });
@@ -689,10 +639,11 @@ function getActiveDraftModeState() {
 /**
 * Read the active request's draft-mode state without recording request API usage.
 * Internal cache implementations use this to bypass persistent reads and writes,
-* matching Next.js's request-level `workStore.isDraftMode` guard.
+* matching Next.js's request-level `workStore.isDraftMode` guard. Once the
+* headers context is cleared, the request keeps the state it had then.
 */
 function isDraftModeEnabled() {
-	return getActiveDraftModeState() ?? false;
+	return getActiveDraftModeState() ?? (isInsideUnifiedScope() && getRequestContext().draftModeAtHeadersClear === true);
 }
 function createDraftModeScopeError(expression) {
 	return /* @__PURE__ */ new Error(`${expression} can only be called from a Server Component, Route Handler, or Server Action.`);
@@ -761,7 +712,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 +829,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/internal/cache-context-accessor.d.ts

@@ -1,4 +1,4 @@
-import { CacheLifeConfig } from "../cache-request-state.js";
+import { CacheLifeConfig } from "../../utils/cache-life-profiles.js";
 //#region src/shims/internal/cache-context-accessor.d.ts
 type CacheContextLike = {
   tags: string[];

package/dist/shims/internal/navigation-untracked.js

@@ -1,5 +1,5 @@
-import { getNavigationContext } from "../navigation-context-state.js";
 import { getPagesNavigationContext } from "./pages-router-accessor.js";
+import { getNavigationContext } from "../navigation-context-state.js";
 import { getClientNavigationState, useClientNavigationRenderSnapshot } from "../navigation.js";
 //#region src/shims/internal/navigation-untracked.ts
 /**

package/dist/shims/link.js

@@ -149,7 +149,7 @@ function getLinkPrefetchRouterMode() {
 /**
 * Prefetch a URL for faster navigation.
 *
-* For App Router (RSC): fetches the .rsc payload in the background and
+* 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: warms the page chunk, prefetches data only for SSG pages,
 * and falls back to a document prefetch hint when no page loader matches.
@@ -192,7 +192,7 @@ function prefetchUrl(href, mode, priority = "low", pagesRouteHref, locale, owner
 				]);
 				if (routeManifestLoaded === false) return;
 				if (navigationEpoch !== linkPrefetchNavigationEpoch) return;
-				const { getPrefetchInterceptionContext, getPrefetchCache, getPrefetchedUrls, getMountedSlotsHeader, createAppPrefetchRequestHeaders, discardLearningOnlyPrefetchCacheEntry, fetchRouteTreeGatedPrefetch, hasFreshLearningOnlyPrefetchCacheEntry, hasSearchAgnosticPrefetchShellForRoute, hasPrefetchCacheEntryForNavigation, prefetchRscResponse, prepareNavigationPrefetchSnapshot, promotePrefetchCacheEntryForNavigation, DYNAMIC_NAVIGATION_CACHE_TTL, PREFETCH_CACHE_TTL } = navigation;
+				const { getPrefetchInterceptionContext, getPrefetchCache, getPrefetchedUrls, getMountedSlotsHeader, createAppPrefetchRequestHeaders, discardLearningOnlyPrefetchCacheEntry, fetchRouteTreeGatedPrefetch, hasFreshLearningOnlyPrefetchCacheEntry, hasSearchAgnosticPrefetchShellForRoute, hasPrefetchCacheEntryForNavigation, prefetchRscResponse, prepareNavigationPrefetchSnapshot, promotePrefetchCacheEntryForNavigation, seedFullPrefetchFromVisitedResponse, hasNavigationFreshVisitedResponse, DYNAMIC_NAVIGATION_CACHE_TTL, PREFETCH_CACHE_TTL } = navigation;
 				const { createRscRequestUrl } = rscCacheBusting;
 				const { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, VINEXT_MOUNTED_SLOTS_HEADER } = headersModule;
 				const hybridOwner = HAS_PAGES_ROUTER ? hybridRouteOwner.resolveHybridClientRouteOwner(prefetchHref, __basePath) : null;
@@ -314,6 +314,8 @@ function prefetchUrl(href, mode, priority = "low", pagesRouteHref, locale, owner
 					}
 					return;
 				}
+				if (autoPrefetch.dynamicStaleTime === "full-prefetch" && seedFullPrefetchFromVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, additionalRscUrls)) return;
+				if (autoPrefetch.dynamicStaleTime !== "full-prefetch" && hasNavigationFreshVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, additionalRscUrls)) return;
 				prefetched.add(cacheKey);
 				const gateViaRouteTree = (__prefetchInlining || requiresRouteTreePrefetch) && mode === "auto" && autoPrefetch.prefetchShellFirst;
 				const gateViaExplicitSearchShell = mode === "full" && hasSearchParams && autoPrefetch.prefetchShellFirst && mountedSlotsHeader === null;
@@ -379,7 +381,7 @@ function prefetchUrl(href, mode, priority = "low", pagesRouteHref, locale, owner
 async function promotePrefetchEntriesForNavigation(href) {
 	if (typeof window === "undefined") return;
 	if (!hasLinkAppNavigationRuntime()) return;
-	const [{ getMountedSlotsHeader, getPrefetchCache, getPrefetchInterceptionContext, promotePrefetchCacheEntryForNavigation }, { parseRscRequestPath, stripRscCacheBustingSearchParam, stripRscSuffix }] = await Promise.all([loadNavigationModule(), loadAppRscCacheBustingModule()]);
+	const [{ getMountedSlotsHeader, getPrefetchCache, getPrefetchInterceptionContext, promotePrefetchCacheEntryForNavigation }, { parseRscRequestPath, stripRscCacheBustingSearchParam }] = await Promise.all([loadNavigationModule(), loadAppRscCacheBustingModule()]);
 	let target;
 	const fullHref = toCanonicalBrowserNavigationHref(href, window.location.href, __basePath, __trailingSlash);
 	try {
@@ -403,7 +405,7 @@ async function promotePrefetchEntriesForNavigation(href) {
 			continue;
 		}
 		stripRscCacheBustingSearchParam(cached);
-		if (stripRscSuffix(cached.pathname) === target.pathname && cached.search === target.search) promotePrefetchCacheEntryForNavigation(cacheKey, entry);
+		if (cached.pathname === target.pathname && cached.search === target.search) promotePrefetchCacheEntryForNavigation(cacheKey, entry);
 	}
 }
 /**
@@ -625,16 +627,11 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 		})
 	});
 	const [pending, setPending] = useState(false);
-	const mountedRef = useRef(true);
 	const pendingPagesIntentPrefetchRef = useRef(null);
-	const setPendingRef = useRef((next) => {
-		if (mountedRef.current) setPending(next);
-	});
+	const setPendingRef = useRef(setPending);
 	useEffect(() => {
-		mountedRef.current = true;
 		const setter = setPendingRef.current;
 		return () => {
-			mountedRef.current = false;
 			pendingPagesIntentPrefetchRef.current?.();
 			pendingPagesIntentPrefetchRef.current = null;
 			if (setter) clearLinkForCurrentNavigation(setter);
@@ -800,7 +797,7 @@ const Link = forwardRef(function Link({ href, as, replace = false, prefetch: pre
 			setPending(true);
 			React.startTransition(() => {
 				navigateClientSide(navigateHref, replace ? "replace" : "push", scroll, false).finally(() => {
-					if (mountedRef.current) setPending(false);
+					setPending(false);
 					if (setter) clearLinkForCurrentNavigation(setter);
 				});
 			});