vinext 1.4.0 → 1.4.2

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/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.
@@ -381,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 {
@@ -405,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);
 	}
 }
 /**
@@ -627,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);
@@ -802,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);
 				});
 			});

package/dist/shims/navigation.js

@@ -11,7 +11,7 @@ import { resolveDirectHybridClientRouteOwner } from "./internal/hybrid-client-ro
 import { isHashOnlyBrowserUrlChange, toCanonicalBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
 import { disableSmoothScrollDuringRouteTransition } from "./disable-smooth-scroll.js";
 import { retryScrollTo, scrollToHashTarget } from "./hash-scroll.js";
-import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, formatRscRequestPath, parseRscRequestPath, stripRscCacheBustingSearchParam, stripRscSuffix } from "../server/app-rsc-cache-busting.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, formatRscRequestPath, parseRscRequestPath, stripRscCacheBustingSearchParam } from "../server/app-rsc-cache-busting.js";
 import { clearAppNavigationFailureTarget, stageAppNavigationFailureTarget } from "../client/app-nav-failure-handler.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import { getNavigationRuntime, hasAppNavigationRuntime, loadNavigationRuntimeRouteManifest } from "../client/navigation-runtime.js";
@@ -245,8 +245,7 @@ function normalizeRscCacheLookupUrl(rscUrl) {
 }
 function normalizeRscCacheLookupPathname(rscUrl) {
 	try {
-		const url = parseRscRequestPath(rscUrl);
-		return stripRscSuffix(url.pathname);
+		return parseRscRequestPath(rscUrl).pathname;
 	} catch {
 		return null;
 	}

package/dist/shims/request-state-types.d.ts

@@ -1,3 +1,4 @@
+import { CacheLifeConfig } from "../utils/cache-life-profiles.js";
 import { NavigationContext } from "./navigation-context-state.js";
 import "./navigation.js";
 import { ExecutionContextLike } from "./request-context.js";
@@ -6,7 +7,7 @@ import { FetchCacheState } from "./fetch-cache-state.js";
 import "./fetch-cache.js";
 import { HeadersAccessPhase, VinextHeadersShimState } from "./internal/headers-state.js";
 import { HeadersContext } from "./headers.js";
-import { CacheLifeConfig, CacheState } from "./cache-request-state.js";
+import { CacheState } from "./cache-request-state.js";
 import { RouterState, SSRContext } from "./router-state.js";
 import { PrivateCacheState } from "./cache-runtime.js";
 import { HeadState } from "./head-state.js";

package/dist/shims/slot.d.ts

@@ -28,10 +28,13 @@ export declare function setAppElementsRenderedSearch(elements: AppElements, sear
  * that arrives after the head (initial hydration) is still seen.
  */
 export declare function bindAppElementsRenderedSearch(elements: AppElements, snapshot: Pick<ClientNavigationRenderSnapshot, "renderedSearch" | "search">): void;
+export declare function isBfcacheIdentityRetained(identity: string): boolean;
 export declare const BfcacheIdentityMapContext: React$1.Context<Readonly<Record<string, string>>>;
 export type BfcacheSlotEntry = {
   content: React$1.ReactNode;
   elements?: AppElements;
+  /** Every entry key inside a hidden entry, its own included. */
+  retainedKeys?: readonly string[];
   segmentId?: string;
   stateKey: string;
   stateKeyMap?: Readonly<Record<string, string>>;
@@ -40,6 +43,7 @@ type MergeElementsOptions = {
   clearAbsentSlots?: boolean;
   preserveAbsentSlots?: boolean;
   preserveElementIds?: readonly string[];
+  preserveElementSeedIds?: readonly string[];
   preservePreviousSlotIds?: readonly string[];
 };
 export declare function updateBfcacheSlotEntryOrder(previousOrder: readonly string[], activeStateKey: string, maxEntries?: number): string[];
@@ -67,9 +71,12 @@ export declare function BfcacheSegmentBoundary({ children, id, stateKey }: {
  * the parent's layout router, above the child's boundaries, so a page left for a
  * sibling with its own layout keeps its state when navigating back.
  */
-export declare function BfcacheChildrenBoundary({ children, id }: {
+export declare function BfcacheChildrenBoundary({ children, id, stateKey }: {
   children: React$1.ReactNode;
-  id: string;
+  /** The child element whose identity keys the entries. */
+  id?: string;
+  /** A fixed key, for a segment level with no element of its own. */
+  stateKey?: string;
 }): React$1.JSX.Element;
 export declare function getNonCacheComponentsSegmentKey(id: string, activeStateKey: string): string | undefined;
 export declare function resolveBfcacheSegmentStateKey(id: string, identityMap: Readonly<Record<string, string>>, bfcacheIdMap: Readonly<Record<string, string>> | null): string | undefined;

package/dist/shims/slot.js

@@ -1,6 +1,6 @@
 "use client";
 import { APP_BFCACHE_SEGMENT_IDENTITIES_KEY, AppElementsWire, UNMATCHED_SLOT } from "../server/app-elements-wire.js";
-import "../server/app-elements.js";
+import { readOptimisticStateKeyRebinder } from "../server/app-elements.js";
 import { isNestedBfcacheSlotSegmentId, isNestedBfcacheSlotSegmentIdFor } from "../server/bfcache-identity.js";
 import { notFound } from "./navigation-errors.js";
 import { getBfcacheIdMapContext, getBfcacheSegmentIdContext } from "./navigation-context-state.js";
@@ -51,6 +51,25 @@ const BfcacheSegmentIdContext = getBfcacheSegmentIdContext();
 const EMPTY_BFCACHE_STATE_KEYS = Object.freeze({});
 const MAX_BFCACHE_SLOT_ENTRIES_WITH_CACHE_COMPONENTS = 3;
 const MAX_BFCACHE_SLOT_ENTRIES_WITHOUT_CACHE_COMPONENTS = 1;
+const rootBfcacheRetainedKeysReports = /* @__PURE__ */ new Map();
+function isBfcacheIdentityRetained(identity) {
+	return hasBfcacheRetainedKey(rootBfcacheRetainedKeysReports, identity);
+}
+function hasBfcacheRetainedKey(reports, identity) {
+	for (const report of reports.values()) {
+		if (report.keys.includes(identity) || report.hiddenKeys.includes(identity)) return true;
+		if (hasBfcacheRetainedKey(report.activeReports, identity)) return true;
+	}
+	return false;
+}
+const BfcacheRetainedKeysContext = React$1.createContext(rootBfcacheRetainedKeysReports);
+function collectBfcacheRetainedKeys(reports, keys) {
+	for (const report of reports.values()) {
+		for (const key of report.keys) keys.add(key);
+		for (const key of report.hiddenKeys) keys.add(key);
+		collectBfcacheRetainedKeys(report.activeReports, keys);
+	}
+}
 const BfcacheIdentityMapContext = React$1.createContext(EMPTY_BFCACHE_STATE_KEYS);
 function isCacheComponentsEnabled() {
 	return String(process.env.__NEXT_CACHE_COMPONENTS) === "true";
@@ -136,34 +155,71 @@ function warnTransportMetadataEntry(id) {
 * falling back to the live boundary values for entries that predate per-entry
 * capture.
 */
-function BfcacheEntryProviders({ entry, fallbackElements, fallbackSegmentId, fallbackStateKeyMap, SegmentContext }) {
+function BfcacheEntryProviders({ entry, fallbackElements, fallbackSegmentId, fallbackStateKeyMap, retainedKeysReports, SegmentContext }) {
 	return /* @__PURE__ */ jsx(BfcacheIdentityMapContext.Provider, {
 		value: entry.stateKeyMap ?? fallbackStateKeyMap,
 		children: /* @__PURE__ */ jsx(ElementsContext.Provider, {
 			value: entry.elements ?? fallbackElements,
 			children: /* @__PURE__ */ jsx(SegmentContext.Provider, {
 				value: entry.segmentId ?? fallbackSegmentId,
-				children: entry.content
+				children: /* @__PURE__ */ jsx(BfcacheRetainedKeysContext.Provider, {
+					value: retainedKeysReports,
+					children: entry.content
+				})
 			})
 		})
 	});
 }
-function useBfcacheSlotEntries(activeEntry) {
+function useBfcacheSlotEntries(listId, activeEntry) {
 	const snapshotsByStateKey = React$1.useRef(/* @__PURE__ */ new Map());
 	const [entryOrder, setEntryOrder] = React$1.useState(() => [activeEntry.stateKey]);
+	const [retainedKeysReportsByStateKey] = React$1.useState(() => /* @__PURE__ */ new Map());
+	const getRetainedKeysReports = (stateKey) => {
+		let reports = retainedKeysReportsByStateKey.get(stateKey);
+		if (!reports) {
+			reports = /* @__PURE__ */ new Map();
+			retainedKeysReportsByStateKey.set(stateKey, reports);
+		}
+		return reports;
+	};
 	const committedSnapshots = snapshotsByStateKey.current;
 	const staged = stageBfcacheSlotEntryForRender(committedSnapshots, entryOrder, activeEntry);
+	for (const [index, entry] of staged.entries.entries()) {
+		if (entry.stateKey === activeEntry.stateKey || entry.retainedKeys) continue;
+		const retainedKeys = /* @__PURE__ */ new Set([entry.stateKey]);
+		collectBfcacheRetainedKeys(getRetainedKeysReports(entry.stateKey), retainedKeys);
+		const hiddenEntry = {
+			...entry,
+			retainedKeys: [...retainedKeys]
+		};
+		staged.entries[index] = hiddenEntry;
+		staged.snapshots.set(entry.stateKey, hiddenEntry);
+	}
 	const nextOrder = staged.order;
 	const orderChanged = !haveSameBfcacheSlotEntryOrder(entryOrder, nextOrder);
 	React$1.useLayoutEffect(() => {
 		snapshotsByStateKey.current = staged.snapshots;
-	}, [staged.snapshots]);
+		for (const stateKey of retainedKeysReportsByStateKey.keys()) if (!staged.snapshots.has(stateKey)) retainedKeysReportsByStateKey.delete(stateKey);
+	}, [retainedKeysReportsByStateKey, staged.snapshots]);
+	const hiddenKeys = [...new Set(staged.entries.flatMap((entry) => entry.retainedKeys ?? []))];
+	const enclosingReports = React$1.useContext(BfcacheRetainedKeysContext);
+	const report = {
+		activeReports: getRetainedKeysReports(activeEntry.stateKey),
+		hiddenKeys,
+		keys: staged.entries.map((entry) => entry.stateKey)
+	};
+	React$1.useLayoutEffect(() => {
+		enclosingReports.set(listId, report);
+	});
 	if (process.env.NODE_ENV !== "production" && !staged.snapshots.has(activeEntry.stateKey)) throw new Error("BFCache Activity slot is missing the active entry snapshot");
 	if (orderChanged) setEntryOrder(nextOrder);
-	return staged.entries;
+	return {
+		entries: staged.entries,
+		getRetainedKeysReports
+	};
 }
 function BfcacheActivitySlotBoundary({ activeStateKey, content, elements, id, SegmentContext, stateKeyMap }) {
-	const renderEntries = useBfcacheSlotEntries({
+	const { entries: renderEntries, getRetainedKeysReports } = useBfcacheSlotEntries(id, {
 		content,
 		elements,
 		segmentId: id,
@@ -177,6 +233,7 @@ function BfcacheActivitySlotBoundary({ activeStateKey, content, elements, id, Se
 			fallbackElements: elements,
 			fallbackSegmentId: id,
 			fallbackStateKeyMap: stateKeyMap,
+			retainedKeysReports: getRetainedKeysReports(entry.stateKey),
 			SegmentContext
 		})
 	}, entry.stateKey)) });
@@ -213,21 +270,23 @@ function BfcacheSegmentBoundary({ children, id, stateKey }) {
 * the parent's layout router, above the child's boundaries, so a page left for a
 * sibling with its own layout keeps its state when navigating back.
 */
-function BfcacheChildrenBoundary({ children, id }) {
+function BfcacheChildrenBoundary({ children, id, stateKey }) {
 	if (!BfcacheIdMapContext || !BfcacheSegmentIdContext || !isCacheComponentsEnabled()) return /* @__PURE__ */ jsx(Fragment$1, { children });
 	return /* @__PURE__ */ jsx(BfcacheChildrenActivityBoundary, {
 		id,
 		IdMapContext: BfcacheIdMapContext,
 		SegmentContext: BfcacheSegmentIdContext,
+		stateKey,
 		children
 	});
 }
-function BfcacheChildrenActivityBoundary({ children, id, IdMapContext, SegmentContext }) {
+function BfcacheChildrenActivityBoundary({ children, id, IdMapContext, SegmentContext, stateKey }) {
 	const elements = React$1.useContext(ElementsContext);
 	const identityMap = React$1.useContext(BfcacheIdentityMapContext);
 	const bfcacheIdMap = React$1.useContext(IdMapContext);
 	const segmentId = React$1.useContext(SegmentContext);
-	const activeStateKey = resolveBfcacheSegmentStateKey(id, identityMap, bfcacheIdMap);
+	const rebindStateKey = readOptimisticStateKeyRebinder(elements);
+	const activeStateKey = stateKey !== void 0 ? rebindStateKey?.(stateKey) ?? stateKey : id === void 0 ? void 0 : resolveBfcacheSegmentStateKey(id, identityMap, bfcacheIdMap);
 	if (segmentId === null || activeStateKey === void 0) return /* @__PURE__ */ jsx(Fragment$1, { children });
 	return /* @__PURE__ */ jsx(BfcacheActivitySlotBoundary, {
 		activeStateKey,
@@ -272,6 +331,7 @@ function mergeElements(prev, next, options = {}) {
 	const clearAbsentSlots = typeof options === "boolean" ? options : options.clearAbsentSlots ?? false;
 	const preserveAbsentSlots = typeof options === "boolean" ? !options : options.preserveAbsentSlots ?? true;
 	const preserveElementIds = typeof options === "boolean" ? [] : options.preserveElementIds ?? [];
+	const preserveElementSeedIds = typeof options === "boolean" ? [] : options.preserveElementSeedIds ?? [];
 	const preservePreviousSlotIds = typeof options === "boolean" ? [] : options.preservePreviousSlotIds ?? [];
 	const merged = { ...next };
 	const preservedIdentityIds = /* @__PURE__ */ new Set();
@@ -282,6 +342,11 @@ function mergeElements(prev, next, options = {}) {
 			preservedIdentityIds.add(id);
 		}
 	}
+	for (const id of preserveElementSeedIds) {
+		if (preservedIdentityIds.has(id) || !Object.hasOwn(prev, id)) continue;
+		const value = prev[id];
+		if (value !== void 0) merged[id] = value;
+	}
 	const slotKeys = new Set([...Object.keys(prev), ...Object.keys(next)].filter((key) => AppElementsWire.isSlotId(key) && !isNestedBfcacheSlotSegmentId(key)));
 	if (clearAbsentSlots) {
 		for (const key of slotKeys) if (!Object.hasOwn(next, key)) delete merged[key];
@@ -368,4 +433,4 @@ function ParallelSlot({ name }) {
 	return React$1.useContext(ParallelSlotsContext)?.[name] ?? null;
 }
 //#endregion
-export { BfcacheChildrenBoundary, BfcacheIdentityMapContext, BfcacheSegmentBoundary, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, RenderedSearchContext, Slot, UNMATCHED_SLOT, bindAppElementsRenderedSearch, getNonCacheComponentsSegmentKey, mergeElements, resolveBfcacheSegmentStateKey, setAppElementsRenderedSearch, stageBfcacheSlotEntryForRender, updateBfcacheSlotEntryOrder };
+export { BfcacheChildrenBoundary, BfcacheIdentityMapContext, BfcacheSegmentBoundary, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, RenderedSearchContext, Slot, UNMATCHED_SLOT, bindAppElementsRenderedSearch, getNonCacheComponentsSegmentKey, isBfcacheIdentityRetained, mergeElements, resolveBfcacheSegmentStateKey, setAppElementsRenderedSearch, stageBfcacheSlotEntryForRender, updateBfcacheSlotEntryOrder };

package/dist/shims/unified-request-context.d.ts

@@ -30,6 +30,12 @@ export type UnifiedRequestContext = {
   requestCache: WeakMap<(...args: any[]) => any, unknown>;
   /** Shared lifecycle state for work deferred until the response closes. */
   afterContext: AfterRequestContext;
+  /**
+   * Draft-mode state of the headers context this request last cleared. The
+   * render can outlive its headers context (cleared once the response body
+   * closes), and so do after() callbacks; cache bypasses keep reading this.
+   */
+  draftModeAtHeadersClear: boolean;
 } & VinextHeadersShimState & I18nState & NavigationState & CacheState & PrivateCacheState & FetchCacheState & RouterState & HeadState & RootParamsState;
 export type AfterRequestContext = {
   callbacks: Array<() => unknown>;

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

@@ -53,6 +53,7 @@ function createRequestContext(opts) {
 		executionContext: _getInheritedExecutionContext(),
 		requestSignal: null,
 		requestCache: /* @__PURE__ */ new WeakMap(),
+		draftModeAtHeadersClear: false,
 		afterContext: {
 			callbacks: [],
 			responseClosed: false,

package/dist/utils/base-path.d.ts

@@ -21,6 +21,13 @@ export declare function stripBasePath(pathname: string, basePath: string): strin
  * this pathname-only helper.
  */
 export declare function addBasePathToPathname(pathname: string, basePath: string | undefined): string;
+/**
+ * Re-add a basePath that `stripBasePath` removed. Unlike
+ * `addBasePathToPathname`, this always prepends it: a stripped route whose
+ * first segment equals the basePath (basePath "/docs", route "/docs/a") still
+ * starts with the basePath and must not be mistaken for the original URL.
+ */
+export declare function restoreBasePath(pathname: string, basePath: string | undefined): string;
 /**
  * Remove trailing slashes from a pathname while preserving the root "/".
  * Collapses any number of trailing slashes ("/a//" → "/a"). Used by the

package/dist/utils/base-path.js

@@ -31,6 +31,16 @@ function addBasePathToPathname(pathname, basePath) {
 	return pathname === "/" ? basePath : `${basePath}${pathname}`;
 }
 /**
+* Re-add a basePath that `stripBasePath` removed. Unlike
+* `addBasePathToPathname`, this always prepends it: a stripped route whose
+* first segment equals the basePath (basePath "/docs", route "/docs/a") still
+* starts with the basePath and must not be mistaken for the original URL.
+*/
+function restoreBasePath(pathname, basePath) {
+	if (!basePath) return pathname;
+	return pathname === "/" ? basePath : `${basePath}${pathname}`;
+}
+/**
 * Remove trailing slashes from a pathname while preserving the root "/".
 * Collapses any number of trailing slashes ("/a//" → "/a"). Used by the
 * trailing-slash redirect path and route pattern normalization.
@@ -42,4 +52,4 @@ function removeTrailingSlash(pathname) {
 	return end === 0 ? "/" : pathname.slice(0, end);
 }
 //#endregion
-export { addBasePathToPathname, hasBasePath, removeTrailingSlash, stripBasePath };
+export { addBasePathToPathname, hasBasePath, removeTrailingSlash, restoreBasePath, stripBasePath };

package/dist/utils/cache-life-profiles.d.ts

@@ -0,0 +1,33 @@
+//#region src/utils/cache-life-profiles.d.ts
+export type CacheLifeConfig = {
+  stale?: number;
+  revalidate?: number;
+  expire?: number;
+};
+/** Next.js's built-in profiles (`defaultConfig.cacheLife` in config-shared.ts). */
+export declare const BUILT_IN_CACHE_LIFE_PROFILES: Readonly<Record<string, Readonly<CacheLifeConfig>>>;
+/**
+ * Merge next.config `cacheLife` profiles over the built-ins, as Next.js does
+ * in `assignDefaultsAndValidate` (server/config.ts): a user profile replaces
+ * the built-in of the same name whole, and only `default` gets its missing
+ * fields filled: `stale` from `staleTimes.static`, `revalidate` from the
+ * built-in, `expire` from `expireTime`. That includes the built-in `default`,
+ * whose `stale` is unset in Next.js's defaults too. The other profiles keep
+ * their gaps, which the "use cache" store resolves from `default`.
+ *
+ * Next.js only schema-checks these profiles (fields must be numbers) and
+ * warns; `revalidate > expire` is checked for `cacheLife({...})` calls, not
+ * for config profiles.
+ */
+export declare function resolveCacheLifeProfiles(userProfiles: unknown, defaults: {
+  expireTime: number;
+  staticStaleTime: number;
+}, warn: (message: string) => void): Record<string, CacheLifeConfig>;
+/** Serialize resolved profiles for the `__VINEXT_CACHE_LIFE_PROFILES` define. */
+export declare function serializeCacheLifeProfiles(profiles: Record<string, CacheLifeConfig>): string;
+/**
+ * Read the `__VINEXT_CACHE_LIFE_PROFILES` define. When absent, the profiles a
+ * next.config without `cacheLife` resolves to.
+ */
+export declare function parseCacheLifeProfiles(serialized: string | undefined): Record<string, CacheLifeConfig>;
+//#endregion

package/dist/utils/cache-life-profiles.js

@@ -0,0 +1,111 @@
+import { isUnknownRecord } from "./record.js";
+//#region src/utils/cache-life-profiles.ts
+/** Next.js's built-in profiles (`defaultConfig.cacheLife` in config-shared.ts). */
+const BUILT_IN_CACHE_LIFE_PROFILES = {
+	default: {
+		revalidate: 900,
+		expire: 4294967294
+	},
+	seconds: {
+		stale: 30,
+		revalidate: 1,
+		expire: 60
+	},
+	minutes: {
+		stale: 300,
+		revalidate: 60,
+		expire: 3600
+	},
+	hours: {
+		stale: 300,
+		revalidate: 3600,
+		expire: 86400
+	},
+	days: {
+		stale: 300,
+		revalidate: 86400,
+		expire: 604800
+	},
+	weeks: {
+		stale: 300,
+		revalidate: 604800,
+		expire: 2592e3
+	},
+	max: {
+		stale: 300,
+		revalidate: 2592e3,
+		expire: 31536e3
+	}
+};
+const CACHE_LIFE_FIELDS = [
+	"stale",
+	"revalidate",
+	"expire"
+];
+function copyBuiltInProfiles() {
+	const profiles = {};
+	for (const [name, profile] of Object.entries(BUILT_IN_CACHE_LIFE_PROFILES)) profiles[name] = { ...profile };
+	return profiles;
+}
+/**
+* Merge next.config `cacheLife` profiles over the built-ins, as Next.js does
+* in `assignDefaultsAndValidate` (server/config.ts): a user profile replaces
+* the built-in of the same name whole, and only `default` gets its missing
+* fields filled: `stale` from `staleTimes.static`, `revalidate` from the
+* built-in, `expire` from `expireTime`. That includes the built-in `default`,
+* whose `stale` is unset in Next.js's defaults too. The other profiles keep
+* their gaps, which the "use cache" store resolves from `default`.
+*
+* Next.js only schema-checks these profiles (fields must be numbers) and
+* warns; `revalidate > expire` is checked for `cacheLife({...})` calls, not
+* for config profiles.
+*/
+function resolveCacheLifeProfiles(userProfiles, defaults, warn) {
+	const profiles = copyBuiltInProfiles();
+	for (const [name, rawProfile] of Object.entries(isUnknownRecord(userProfiles) ? userProfiles : {})) {
+		if (!isUnknownRecord(rawProfile)) {
+			warn(`[vinext] Invalid next.config option \`cacheLife.${name}\`: expected an object.`);
+			continue;
+		}
+		const profile = {};
+		for (const field of CACHE_LIFE_FIELDS) {
+			const value = rawProfile[field];
+			if (value === void 0) continue;
+			if (typeof value !== "number" || Number.isNaN(value)) {
+				warn(`[vinext] Invalid next.config option \`cacheLife.${name}.${field}\`: expected a number of seconds.`);
+				continue;
+			}
+			profile[field] = value;
+		}
+		profiles[name] = profile;
+	}
+	const defaultProfile = profiles.default;
+	defaultProfile.stale ??= defaults.staticStaleTime;
+	defaultProfile.revalidate ??= BUILT_IN_CACHE_LIFE_PROFILES.default.revalidate;
+	defaultProfile.expire ??= defaults.expireTime;
+	return profiles;
+}
+function encodeNonFiniteNumber(_key, value) {
+	return value === Infinity || value === -Infinity ? String(value) : value;
+}
+function decodeNonFiniteNumber(_key, value) {
+	return value === "Infinity" || value === "-Infinity" ? Number(value) : value;
+}
+/** Serialize resolved profiles for the `__VINEXT_CACHE_LIFE_PROFILES` define. */
+function serializeCacheLifeProfiles(profiles) {
+	return JSON.stringify(profiles, encodeNonFiniteNumber);
+}
+/**
+* Read the `__VINEXT_CACHE_LIFE_PROFILES` define. When absent, the profiles a
+* next.config without `cacheLife` resolves to.
+*/
+function parseCacheLifeProfiles(serialized) {
+	if (!serialized) {
+		const profiles = copyBuiltInProfiles();
+		profiles.default.stale = 300;
+		return profiles;
+	}
+	return JSON.parse(serialized, decodeNonFiniteNumber);
+}
+//#endregion
+export { BUILT_IN_CACHE_LIFE_PROFILES, parseCacheLifeProfiles, resolveCacheLifeProfiles, serializeCacheLifeProfiles };

package/dist/utils/middleware-request-headers.d.ts

@@ -7,7 +7,17 @@ type MiddlewareHeaderSource = Headers | Record<string, MiddlewareHeaderValue>;
  * under their literal protocol-header names on both the request and response.
  */
 export declare function getUnconsumedMiddlewareRequestHeaders(source: MiddlewareHeaderSource): Map<string, string>;
-/** Whether middleware changed the headers seen by downstream application code. */
+/**
+ * `baseHeaders` with only Next.js's generic merge of ordinary middleware
+ * response headers applied, without the request-header protocol.
+ */
+export declare function applyMiddlewareResponseHeadersToRequest(baseHeaders: Headers, middlewareHeaders: MiddlewareHeaderSource): Headers;
+/**
+ * Whether middleware changed the headers seen by downstream application code
+ * through its request-header protocol. Ordinary response headers are copied to
+ * the request as well, but like a client's own headers they do not opt a
+ * render out of the shared response stage.
+ */
 export declare function hasMiddlewareRequestHeaderOverrides(source: MiddlewareHeaderSource | null): boolean;
 export declare function encodeMiddlewareRequestHeaders(targetHeaders: Headers, requestHeaders: Headers): void;
 /**
@@ -16,8 +26,9 @@ export declare function encodeMiddlewareRequestHeaders(targetHeaders: Headers, r
  * middleware. Never re-add absent headers from the base request — that would
  * resurrect credentials the app explicitly stripped before an external
  * rewrite. Next.js treats the empty value emitted for `new Headers()` as no
- * override. Any unconsumed `x-middleware-request-*` values are subsequently
- * copied to the request under their literal protocol-header names.
+ * override. Any unconsumed `x-middleware-request-*` values and every other
+ * truthy middleware response header are subsequently copied to the request
+ * under their literal names, replacing values the client sent.
  */
 export declare function buildRequestHeadersFromMiddlewareResponse(baseHeaders: Headers, middlewareHeaders: MiddlewareHeaderSource): Headers | null;
 export declare function shouldKeepMiddlewareHeader(key: string): boolean;

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

@@ -34,7 +34,52 @@ function getUnconsumedMiddlewareRequestHeaders(source) {
 	for (const [key, value] of getForwardedRequestHeaders(source)) if (value && !overriddenHeaders?.has(key)) unconsumedHeaders.set(`${MIDDLEWARE_REQUEST_HEADER_PREFIX}${key}`, value);
 	return unconsumedHeaders;
 }
-/** Whether middleware changed the headers seen by downstream application code. */
+const UNMERGED_MIDDLEWARE_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
+	"accept-encoding",
+	"connection",
+	"content-encoding",
+	"content-length",
+	"expect",
+	"keep-alive",
+	"keepalive",
+	"transfer-encoding"
+]);
+/**
+* Return the truthy ordinary middleware response headers. Next.js's generic
+* middleware-header merge writes each of them to the request too, so a value
+* middleware sets replaces one the client sent under the same name. The
+* `x-middleware-*` namespace carries vinext's middleware protocol and is
+* handled separately.
+*/
+function getMergedMiddlewareResponseHeaders(source) {
+	const mergedHeaders = new Headers();
+	const entries = source instanceof Headers ? source : Object.entries(source).flatMap(([key, value]) => Array.isArray(value) ? value.map((item) => [key, item]) : [[key, value]]);
+	for (const [key, value] of entries) {
+		const lowerKey = key.toLowerCase();
+		if (value && !lowerKey.startsWith("x-middleware-") && !UNMERGED_MIDDLEWARE_RESPONSE_HEADERS.has(lowerKey)) mergedHeaders.append(lowerKey, value);
+	}
+	return mergedHeaders;
+}
+function applyMergedMiddlewareHeaders(targetHeaders, unconsumedHeaders, mergedHeaders) {
+	for (const [key, value] of unconsumedHeaders) targetHeaders.set(key, value);
+	for (const key of new Set(mergedHeaders.keys())) targetHeaders.delete(key);
+	for (const [key, value] of mergedHeaders) targetHeaders.append(key, value);
+}
+/**
+* `baseHeaders` with only Next.js's generic merge of ordinary middleware
+* response headers applied, without the request-header protocol.
+*/
+function applyMiddlewareResponseHeadersToRequest(baseHeaders, middlewareHeaders) {
+	const nextHeaders = new Headers(baseHeaders);
+	applyMergedMiddlewareHeaders(nextHeaders, /* @__PURE__ */ new Map(), getMergedMiddlewareResponseHeaders(middlewareHeaders));
+	return nextHeaders;
+}
+/**
+* Whether middleware changed the headers seen by downstream application code
+* through its request-header protocol. Ordinary response headers are copied to
+* the request as well, but like a client's own headers they do not opt a
+* render out of the shared response stage.
+*/
 function hasMiddlewareRequestHeaderOverrides(source) {
 	if (!source) return false;
 	return Boolean(getMiddlewareHeaderValue(source, "x-middleware-override-headers")) || getUnconsumedMiddlewareRequestHeaders(source).size > 0;
@@ -50,17 +95,19 @@ function encodeMiddlewareRequestHeaders(targetHeaders, requestHeaders) {
 * middleware. Never re-add absent headers from the base request — that would
 * resurrect credentials the app explicitly stripped before an external
 * rewrite. Next.js treats the empty value emitted for `new Headers()` as no
-* override. Any unconsumed `x-middleware-request-*` values are subsequently
-* copied to the request under their literal protocol-header names.
+* override. Any unconsumed `x-middleware-request-*` values and every other
+* truthy middleware response header are subsequently copied to the request
+* under their literal names, replacing values the client sent.
 */
 function buildRequestHeadersFromMiddlewareResponse(baseHeaders, middlewareHeaders) {
 	const forwardedHeaders = getForwardedRequestHeaders(middlewareHeaders);
 	const unconsumedHeaders = getUnconsumedMiddlewareRequestHeaders(middlewareHeaders);
+	const mergedHeaders = getMergedMiddlewareResponseHeaders(middlewareHeaders);
 	const rawOverrideHeader = getMiddlewareHeaderValue(middlewareHeaders, MIDDLEWARE_OVERRIDE_HEADERS);
 	if (!rawOverrideHeader) {
-		if (unconsumedHeaders.size === 0) return null;
+		if (unconsumedHeaders.size === 0 && mergedHeaders.keys().next().done) return null;
 		const nextHeaders = new Headers(baseHeaders);
-		for (const [key, value] of unconsumedHeaders) nextHeaders.set(key, value);
+		applyMergedMiddlewareHeaders(nextHeaders, unconsumedHeaders, mergedHeaders);
 		return nextHeaders;
 	}
 	const overrideHeaderNames = parseOverrideHeaderNames(rawOverrideHeader);
@@ -69,11 +116,11 @@ function buildRequestHeadersFromMiddlewareResponse(baseHeaders, middlewareHeader
 		const value = forwardedHeaders.get(key);
 		if (value !== void 0) nextHeaders.set(key, value);
 	}
-	for (const [key, value] of unconsumedHeaders) nextHeaders.set(key, value);
+	applyMergedMiddlewareHeaders(nextHeaders, unconsumedHeaders, mergedHeaders);
 	return nextHeaders;
 }
 function shouldKeepMiddlewareHeader(key) {
 	return key === "x-middleware-override-headers" || key === "x-middleware-cache" || key === "x-middleware-set-cookie" || key.startsWith("x-middleware-request-");
 }
 //#endregion
-export { buildRequestHeadersFromMiddlewareResponse, encodeMiddlewareRequestHeaders, getUnconsumedMiddlewareRequestHeaders, hasMiddlewareRequestHeaderOverrides, shouldKeepMiddlewareHeader };
+export { applyMiddlewareResponseHeadersToRequest, buildRequestHeadersFromMiddlewareResponse, encodeMiddlewareRequestHeaders, getUnconsumedMiddlewareRequestHeaders, hasMiddlewareRequestHeaderOverrides, shouldKeepMiddlewareHeader };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vinext",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Run Next.js apps on Vite. Drop-in replacement for the next CLI.",
   "homepage": "https://vinext.dev/",
   "license": "MIT",