vinext 1.3.0 → 1.4.0

package/dist/shims/cache-handler.js

@@ -1,5 +1,5 @@
 import { shareIsolatePromise } from "../server/isolate-shared-promise.js";
-import { readCacheControlNumberField, readCacheControlRevalidateField } from "../utils/cache-control-metadata.js";
+import { readCacheControlNumberField, readCacheControlRevalidateField, readCacheTimestamp } from "../utils/cache-control-metadata.js";
 //#region src/shims/cache-handler.ts
 var NoOpCacheHandler = class {
 	async get(_key, _ctx) {
@@ -48,7 +48,7 @@ function readPositiveNumberField(ctx, field) {
 }
 var MemoryCacheHandler = class {
 	store = /* @__PURE__ */ new Map();
-	tagRevalidatedAt = /* @__PURE__ */ new Map();
+	tagsManifest = /* @__PURE__ */ new Map();
 	maxMemoryCacheSize;
 	currentMemoryCacheSize = 0;
 	constructor(options) {
@@ -77,19 +77,20 @@ var MemoryCacheHandler = class {
 	async get(key, ctx) {
 		const entry = this.store.get(key);
 		if (!entry) return null;
+		const now = Date.now();
+		let hasStaleTag = false;
 		for (const tag of entry.tags) {
-			const revalidatedAt = this.tagRevalidatedAt.get(tag);
-			if (revalidatedAt && revalidatedAt >= entry.lastModified) {
+			if (this.isTagExpired(tag, entry.lastModified, now)) {
 				this.deleteEntry(key);
 				return null;
 			}
+			hasStaleTag ||= this.isTagStale(tag, entry.lastModified);
 		}
 		for (const tag of readStringArrayField(ctx, "softTags")) {
-			const revalidatedAt = this.tagRevalidatedAt.get(tag);
-			if (revalidatedAt && revalidatedAt >= entry.lastModified) return null;
+			if (this.isTagExpired(tag, entry.lastModified, now)) return null;
+			hasStaleTag ||= this.isTagStale(tag, entry.lastModified);
 		}
 		this.touchEntry(key, entry);
-		const now = Date.now();
 		if (entry.expireAt !== null && now > entry.expireAt) return {
 			lastModified: entry.lastModified,
 			value: entry.value,
@@ -98,7 +99,7 @@ var MemoryCacheHandler = class {
 		};
 		const requestedRevalidate = readPositiveNumberField(ctx, "revalidate");
 		const requestedRevalidateAt = requestedRevalidate === void 0 ? null : entry.lastModified + requestedRevalidate * 1e3;
-		if (entry.revalidateAt !== null && now > entry.revalidateAt || requestedRevalidateAt !== null && now > requestedRevalidateAt) return {
+		if (hasStaleTag || entry.revalidateAt !== null && now > entry.revalidateAt || requestedRevalidateAt !== null && now > requestedRevalidateAt) return {
 			lastModified: entry.lastModified,
 			value: entry.value,
 			cacheState: "stale",
@@ -121,7 +122,7 @@ var MemoryCacheHandler = class {
 		if (data && "revalidate" in data && typeof data.revalidate === "number") effectiveRevalidate = data.revalidate;
 		else if (data && "revalidate" in data && data.revalidate === false) effectiveRevalidate ??= false;
 		if (effectiveRevalidate === 0) return;
-		const now = Date.now();
+		const now = readCacheTimestamp(ctx, Date.now());
 		const revalidateAt = typeof effectiveRevalidate === "number" && effectiveRevalidate > 0 ? now + effectiveRevalidate * 1e3 : null;
 		const expireAt = typeof effectiveExpire === "number" && effectiveExpire > 0 ? now + effectiveExpire * 1e3 : null;
 		const cacheControl = typeof effectiveRevalidate === "number" || effectiveRevalidate === false ? {
@@ -148,10 +149,29 @@ var MemoryCacheHandler = class {
 		this.currentMemoryCacheSize += entrySize;
 		this.evictLeastRecentlyUsed();
 	}
-	async revalidateTag(tags) {
+	async revalidateTag(tags, durations) {
 		const tagList = Array.isArray(tags) ? tags : [tags];
 		const now = Date.now();
-		for (const tag of tagList) this.tagRevalidatedAt.set(tag, now);
+		for (const tag of tagList) {
+			const existing = this.tagsManifest.get(tag) ?? {};
+			if (durations) this.tagsManifest.set(tag, {
+				...existing,
+				stale: now,
+				...durations.expire === void 0 ? {} : { expired: now + durations.expire * 1e3 }
+			});
+			else this.tagsManifest.set(tag, {
+				...existing,
+				expired: now
+			});
+		}
+	}
+	isTagExpired(tag, lastModified, now) {
+		const expired = this.tagsManifest.get(tag)?.expired;
+		return expired !== void 0 && expired <= now && expired >= lastModified;
+	}
+	isTagStale(tag, lastModified) {
+		const stale = this.tagsManifest.get(tag)?.stale;
+		return stale !== void 0 && stale > lastModified;
 	}
 	resetRequestCache() {}
 };

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

@@ -8,21 +8,6 @@ export type CacheLifeConfig = {
 export declare const cacheLifeProfiles: Record<string, CacheLifeConfig>;
 export type UnstableCacheRevalidationMode = "foreground" | "background";
 export type ActionRevalidationKind = 0 | 1 | 2;
-export type UnstableCacheObservation = Readonly<{
-  kind: "unstable_cache";
-  keyHash: string;
-  revalidate: number | false | null;
-  tagCount: number;
-  tagHash: string | null;
-}>;
-/**
- * Collects the cacheLife claims made anywhere below the scope that installed
- * it, including nested scopes that reset `requestScopedCacheLife`. Shallow
- * scope clones share it by reference.
- */
-export type CacheLifeSink = {
-  cacheLife: CacheLifeConfig | null;
-};
 type TagInvalidationDurations = {
   expire?: number;
 } | undefined;
@@ -34,12 +19,17 @@ export type PendingCdnTagInvalidation = Readonly<{
 }>;
 export type CacheState = {
   actionRevalidationKind: ActionRevalidationKind;
-  cacheLifeSink: CacheLifeSink | null;
+  /**
+   * The request is an authorized on-demand revalidation (`res.revalidate()`).
+   * Like Next.js's `workStore.isOnDemandRevalidate`, the data caches then skip
+   * their reads but still execute and store fresh results. Set once when the
+   * request context is created; nested scopes inherit it.
+   */
+  isOnDemandRevalidate: boolean;
   pendingCdnTagInvalidations: PendingCdnTagInvalidation[];
   pendingRevalidatedTags: Set<string>;
   pendingRevalidations: Set<Promise<void>>;
   requestScopedCacheLife: CacheLifeConfig | null;
-  unstableCacheObservations: Map<string, UnstableCacheObservation>;
   unstableCacheRevalidation: UnstableCacheRevalidationMode;
 };
 export declare const ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC = 1;
@@ -47,6 +37,15 @@ export declare const ACTION_DID_REVALIDATE_DYNAMIC_ONLY = 2;
 export declare function _runWithCacheState<T>(fn: () => Promise<T>): Promise<T>;
 export declare function _runWithCacheState<T>(fn: () => T | Promise<T>): T | Promise<T>;
 export declare function _initRequestScopedCacheState(): void;
+/**
+ * Whether the current request is an authorized on-demand revalidation, so the
+ * data caches must skip their reads (not their writes). Mirrors Next.js's
+ * `workStore.isOnDemandRevalidate` checks in use-cache-wrapper, patch-fetch
+ * and unstable-cache.
+ *
+ * @internal
+ */
+export declare function _isOnDemandRevalidate(): boolean;
 export declare function markActionRevalidation(kind: ActionRevalidationKind): void;
 export declare function getAndClearActionRevalidationKind(): ActionRevalidationKind;
 /** @internal */
@@ -114,11 +113,9 @@ export declare function _captureRequestScopedCacheLifeAccessors(): {
   consume: () => CacheLifeConfig | null;
   peek: () => CacheLifeConfig | null;
 };
-export declare function recordUnstableCacheObservation(observation: UnstableCacheObservation): void;
-export declare function _peekUnstableCacheObservations(): UnstableCacheObservation[];
 /**
  * Run `fn` with the request's cache settings, including its revalidation mode,
- * but its own record of cache lives and unstable_cache observations, so work
+ * but its own record of cache lives, so work
  * done on the request's behalf after the fact leaves the request untouched.
  */
 export declare function runWithDetachedCacheObservations<T>(fn: () => Promise<T>): Promise<T>;

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

@@ -48,12 +48,11 @@ const ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC = 1;
 const ACTION_DID_REVALIDATE_DYNAMIC_ONLY = 2;
 const fallbackState = globalState[FALLBACK_KEY] ??= {
 	actionRevalidationKind: ACTION_DID_NOT_REVALIDATE,
-	cacheLifeSink: null,
+	isOnDemandRevalidate: false,
 	pendingCdnTagInvalidations: [],
 	pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 	pendingRevalidations: /* @__PURE__ */ new Set(),
 	requestScopedCacheLife: null,
-	unstableCacheObservations: /* @__PURE__ */ new Map(),
 	unstableCacheRevalidation: "foreground"
 };
 function getCacheState() {
@@ -63,19 +62,16 @@ function getCacheState() {
 function _runWithCacheState(fn) {
 	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((context) => {
 		context.actionRevalidationKind = ACTION_DID_NOT_REVALIDATE;
-		context.cacheLifeSink = null;
 		context.requestScopedCacheLife = null;
-		context.unstableCacheObservations = /* @__PURE__ */ new Map();
 		context.unstableCacheRevalidation = "foreground";
 	}, fn);
 	const state = {
 		actionRevalidationKind: ACTION_DID_NOT_REVALIDATE,
-		cacheLifeSink: null,
+		isOnDemandRevalidate: false,
 		pendingCdnTagInvalidations: [],
 		pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 		pendingRevalidations: /* @__PURE__ */ new Set(),
 		requestScopedCacheLife: null,
-		unstableCacheObservations: /* @__PURE__ */ new Map(),
 		unstableCacheRevalidation: "foreground"
 	};
 	return cacheAls.run(state, fn);
@@ -84,7 +80,17 @@ function _initRequestScopedCacheState() {
 	const state = getCacheState();
 	state.actionRevalidationKind = ACTION_DID_NOT_REVALIDATE;
 	state.requestScopedCacheLife = null;
-	state.unstableCacheObservations = /* @__PURE__ */ new Map();
+}
+/**
+* Whether the current request is an authorized on-demand revalidation, so the
+* data caches must skip their reads (not their writes). Mirrors Next.js's
+* `workStore.isOnDemandRevalidate` checks in use-cache-wrapper, patch-fetch
+* and unstable-cache.
+*
+* @internal
+*/
+function _isOnDemandRevalidate() {
+	return getCacheState().isOnDemandRevalidate === true;
 }
 function markActionRevalidation(kind) {
 	if (getHeadersAccessPhase() !== "action") return;
@@ -224,7 +230,6 @@ function mergeCacheLife(current, config) {
 function _setRequestScopedCacheLife(config) {
 	const state = getCacheState();
 	state.requestScopedCacheLife = mergeCacheLife(state.requestScopedCacheLife, config);
-	if (state.cacheLifeSink) state.cacheLifeSink.cacheLife = mergeCacheLife(state.cacheLifeSink.cacheLife, config);
 }
 function _peekRequestScopedCacheLife() {
 	const config = getCacheState().requestScopedCacheLife;
@@ -257,32 +262,22 @@ function _captureRequestScopedCacheLifeAccessors() {
 		}
 	};
 }
-function recordUnstableCacheObservation(observation) {
-	getCacheState().unstableCacheObservations.set(observation.keyHash, observation);
-}
-function _peekUnstableCacheObservations() {
-	return [...getCacheState().unstableCacheObservations.values()].sort((a, b) => a.keyHash.localeCompare(b.keyHash));
-}
 /**
 * Run `fn` with the request's cache settings, including its revalidation mode,
-* but its own record of cache lives and unstable_cache observations, so work
+* but its own record of cache lives, so work
 * done on the request's behalf after the fact leaves the request untouched.
 */
 function runWithDetachedCacheObservations(fn) {
 	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((context) => {
-		context.cacheLifeSink = null;
 		context.requestScopedCacheLife = null;
-		context.unstableCacheObservations = /* @__PURE__ */ new Map();
 	}, fn);
 	return cacheAls.run({
 		...getCacheState(),
-		cacheLifeSink: null,
-		requestScopedCacheLife: null,
-		unstableCacheObservations: /* @__PURE__ */ new Map()
+		requestScopedCacheLife: null
 	}, fn);
 }
 function shouldServeStaleUnstableCacheEntry() {
 	return getCacheState().unstableCacheRevalidation === "background";
 }
 //#endregion
-export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _isOnDemandRevalidate, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry };

package/dist/shims/cache-runtime.js

@@ -11,7 +11,7 @@ import { createPprFallbackShellSuspensePromise, trackPprFallbackShellCacheTask }
 import { createUseCacheAccessError, markDynamicUsage, recordInvalidDynamicUsageError } from "./internal/headers-state.js";
 import { isDraftModeEnabled } from "./headers.js";
 import { _registerCacheContextAccessor } from "./internal/cache-context-accessor.js";
-import { _hasPendingRevalidatedTag, _setRequestScopedCacheLife, cacheLifeProfiles, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
+import { _hasPendingRevalidatedTag, _isOnDemandRevalidate, _setRequestScopedCacheLife, cacheLifeProfiles, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
 import "./fetch-cache.js";
 import { hasUseCacheLayoutMarker, hasUseCachePageMarker, isUseCacheFunctionReference, withoutUseCacheSegmentMarker } from "./internal/app-page-props-cache-key.js";
 import { isWellKnownProperty } from "./internal/thenable-well-known-properties.js";
@@ -389,7 +389,7 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 			if (knownRootParamNames && rootParams) cacheKey += computeRootParamsCacheKeySuffix(rootParams, knownRootParamNames);
 			const softTags = getCurrentFetchSoftTags();
 			let existing = null;
-			if (!_hasPendingRevalidatedTag(softTags)) try {
+			if (!_hasPendingRevalidatedTag(softTags) && !_isOnDemandRevalidate()) try {
 				existing = await handler.get(cacheKey, {
 					kind: "FETCH",
 					softTags
@@ -398,8 +398,10 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 				console.error("[vinext] use cache: handler.get failed; treating as a cache miss:", error);
 			}
 			const redirectValue = existing?.value;
+			let staleRedirect;
 			if (isRootParamRedirect(existing) && isServableCacheState(existing?.cacheState) && rootParams && redirectValue?.kind === "FETCH" && !_hasPendingRevalidatedTag([...redirectValue.tags ?? [], ...softTags])) {
 				cacheKey = coarseCacheKey + computeRootParamsCacheKeySuffix(rootParams, addKnownRootParamNames(id, rootParamNamesFromTags(redirectValue.tags)));
+				if (existing?.cacheState) staleRedirect = existing;
 				try {
 					existing = await handler.get(cacheKey, {
 						kind: "FETCH",
@@ -410,7 +412,8 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 					existing = null;
 				}
 			}
-			const generate = async (propagate) => {
+			const generate = async (propagate, staleEntry) => {
+				const timestamp = Date.now();
 				const { result, ctx, effectiveLife, collectedResult } = await runCachedFunctionWithContext(callFn, callArgs, cacheVariant, (value) => serializeCacheResult(value, rsc));
 				const rootParamNames = ctx.readRootParamNames && ctx.readRootParamNames.size > 0 ? addKnownRootParamNames(id, ctx.readRootParamNames) : knownRootParamsByFunctionId.get(id);
 				if (propagate) {
@@ -442,6 +445,7 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 					const cacheContext = {
 						fetchCache: true,
 						tags: ctx.tags,
+						timestamp,
 						...cacheFunctionInvocation ? { cacheFunctionInvocation } : {},
 						cacheControl: {
 							revalidate: revalidateSeconds,
@@ -463,11 +467,18 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 							revalidate: revalidateSeconds
 						}, {
 							...cacheContext,
-							tags: redirectTags
+							tags: redirectTags,
+							...coarseCacheKey === cacheKey ? staleEntry && { staleEntry } : staleRedirect && { staleEntry: staleRedirect }
 						});
 						cacheValue.data.url = specificCacheKey;
-						await handler.set(specificCacheKey, cacheValue, cacheContext);
-					} else await handler.set(cacheKey, cacheValue, cacheContext);
+						await handler.set(specificCacheKey, cacheValue, {
+							...cacheContext,
+							...staleEntry && specificCacheKey === cacheKey ? { staleEntry } : {}
+						});
+					} else await handler.set(cacheKey, cacheValue, {
+						...cacheContext,
+						...staleEntry ? { staleEntry } : {}
+					});
 				} catch {}
 				return collectedResult ? collectedResult.result : result;
 			};
@@ -476,10 +487,13 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 				propagateCacheTagsToRequest(existing.value.tags);
 				const result = await rsc.createFromReadableStream(uint8ToStream(base64ToUint8(existing.value.data.body)), {}, { preserveServerReferences: true });
 				recordRequestScopedCacheControl(existing.cacheControl);
-				if (existing.cacheState === "stale") regenerateInBackground(id, () => generate(false));
+				if (existing.cacheState === "stale") {
+					const staleEntry = existing;
+					regenerateInBackground(id, () => generate(false, staleEntry));
+				}
 				return result;
 			} catch {}
-			return generate(true);
+			return generate(true, existing?.cacheState ? existing : void 0);
 		}, cacheVariant);
 	};
 	const cachedFn = memoizeInCacheScope((...args) => invoke(args));
@@ -589,9 +603,11 @@ async function runCachedFunctionWithContext(fn, args, variant, collectResult) {
 	let collectedResult;
 	const workUnitType = variant === "private" ? "private-cache" : "cache";
 	const result = await workUnitAsyncStorage.run({ type: workUnitType }, () => cacheContextStorage.run(ctx, async () => {
-		const value = await fn(...args);
-		if (collectResult) collectedResult = await collectResult(value, ctx);
-		return value;
+		if (!collectResult) return await fn(...args);
+		let value;
+		const lazyValue = { then: (onFulfilled, onRejected) => (value ??= new Promise((resolve) => resolve(fn(...args)))).then(onFulfilled, onRejected) };
+		collectedResult = await collectResult(lazyValue, ctx);
+		return await lazyValue;
 	}));
 	if (ctx.invalidDynamicUsageError) throw ctx.invalidDynamicUsageError;
 	const effectiveLife = resolveCacheLife(ctx.lifeConfigs);

package/dist/shims/cache.d.ts

@@ -1,7 +1,7 @@
 import { ExecutionContextLike, getRequestExecutionContext, runWithExecutionContext } from "./request-context.js";
-import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
-import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheLifeConfig, CacheLifeSink, CacheState, PendingCdnTagInvalidation, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
 import { CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, registerDataCacheHandler, registerLazyDataCacheHandler, setCacheHandler, setDataCacheHandler } from "./cache-handler.js";
+import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
+import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheLifeConfig, CacheState, PendingCdnTagInvalidation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _isOnDemandRevalidate, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
 //#region src/shims/cache.d.ts
 /**
  * Revalidate cached data associated with a specific cache tag.
@@ -61,10 +61,11 @@ export declare function updateTag(tag: string): undefined;
 /**
  * Opt out of static rendering and indicate a particular component should not be cached.
  *
- * In Next.js, calling noStore() inside a Server Component ensures the component
- * is dynamically rendered. In our implementation, this is a no-op since we don't
- * have the same static/dynamic rendering split — all server rendering is on-demand.
- * It's provided for API compatibility so apps importing it don't break.
+ * Without Cache Components this marks the render dynamic, so the page is not
+ * stored. With Cache Components it does nothing, as in Next.js: its prerenders
+ * ignore it, and on a request it doesn't make the page dynamic, so the page
+ * stays static and cacheable.
+ * Source: https://github.com/vercel/next.js/blob/canary/packages/next/src/server/web/spec-extension/unstable-no-store.ts
  */
 export declare function unstable_noStore(): void;
 /**
@@ -142,4 +143,4 @@ type UnstableCacheOptions = {
  */
 export declare function unstable_cache<T extends (...args: any[]) => Promise<any>>(fn: T, keyParts?: string[], options?: UnstableCacheOptions): T;
 //#endregion
-export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CacheLifeConfig, CacheLifeSink, CacheState, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, type ExecutionContextLike, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, PendingCdnTagInvalidation, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, markActionRevalidation, unstable_noStore as noStore, recordUnstableCacheObservation, registerDataCacheHandler, registerLazyDataCacheHandler, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CacheLifeConfig, CacheState, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, type ExecutionContextLike, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, PendingCdnTagInvalidation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _isOnDemandRevalidate, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, markActionRevalidation, unstable_noStore as noStore, registerDataCacheHandler, registerLazyDataCacheHandler, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry };

package/dist/shims/cache.js

@@ -6,13 +6,13 @@ import { workUnitAsyncStorage } from "./internal/work-unit-async-storage.js";
 import { isStagedCacheabilityProbeActive } from "./cacheability-classification.js";
 import { MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, registerDataCacheHandler, registerLazyDataCacheHandler, setCacheHandler, setDataCacheHandler } from "./cache-handler.js";
 import { encodeCacheTag, encodeCacheTags } from "../utils/encode-cache-tag.js";
-import { fnv1a64, sha256Hex } from "../utils/hash.js";
+import { sha256Hex } from "../utils/hash.js";
 import { addCollectedRequestTags, getCurrentFetchSoftTags, runWithDetachedFetchObservations } from "./fetch-cache-state.js";
 import { makeHangingPromise } from "./internal/make-hanging-promise.js";
 import { getHeadersAccessPhase, markDynamicUsage } from "./internal/headers-state.js";
 import { isDraftModeEnabled } from "./headers.js";
 import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
-import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
+import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _isOnDemandRevalidate, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
 import { isPathKnownNotEdgeCached } from "./cdn-purge-routes.js";
 //#region src/shims/cache.ts
 /**
@@ -154,13 +154,15 @@ function updateTag(tag) {
 /**
 * Opt out of static rendering and indicate a particular component should not be cached.
 *
-* In Next.js, calling noStore() inside a Server Component ensures the component
-* is dynamically rendered. In our implementation, this is a no-op since we don't
-* have the same static/dynamic rendering split — all server rendering is on-demand.
-* It's provided for API compatibility so apps importing it don't break.
+* Without Cache Components this marks the render dynamic, so the page is not
+* stored. With Cache Components it does nothing, as in Next.js: its prerenders
+* ignore it, and on a request it doesn't make the page dynamic, so the page
+* stays static and cacheable.
+* Source: https://github.com/vercel/next.js/blob/canary/packages/next/src/server/web/spec-extension/unstable-no-store.ts
 */
 function unstable_noStore() {
 	if (isInsideUnstableCacheScope()) return;
+	if (String(process.env.__NEXT_CACHE_COMPONENTS) === "true") return;
 	markDynamicUsage();
 }
 /**
@@ -394,7 +396,7 @@ function scheduleUnstableCacheBackgroundRevalidation(cacheKey, refresh) {
 	pending.set(cacheKey, trackedRevalidation);
 	waitUntilUnstableCacheRevalidation(trackedRevalidation);
 }
-async function refreshUnstableCacheResult(fn, args, keyedArgs, cacheKey, tags, revalidateSeconds) {
+async function refreshUnstableCacheResult(fn, args, keyedArgs, cacheKey, tags, revalidateSeconds, staleEntry) {
 	const argsUnchanged = serializeArgsOrNull(args) === keyedArgs;
 	const result = await _unstableCacheAls.run(true, () => _unstableCacheCallbackAls.run({ useCacheContext: _useCacheContextAls.getStore() }, () => fn(...args)));
 	if (!argsUnchanged) return result;
@@ -411,7 +413,8 @@ async function refreshUnstableCacheResult(fn, args, keyedArgs, cacheKey, tags, r
 	await getDataCacheHandler().set(cacheKey, cacheValue, {
 		fetchCache: true,
 		tags,
-		revalidate: revalidateSeconds
+		revalidate: revalidateSeconds,
+		...staleEntry ? { staleEntry } : {}
 	});
 	return result;
 }
@@ -439,16 +442,10 @@ function unstable_cache(fn, keyParts, options) {
 		const keyedArgs = JSON.stringify(args);
 		const invocationKey = `${fixedKey}${keyedArgs}`;
 		addCollectedRequestTags(tags);
-		recordUnstableCacheObservation({
-			kind: "unstable_cache",
-			keyHash: fnv1a64(invocationKey),
-			revalidate: typeof revalidateSeconds === "number" ? revalidateSeconds : revalidateSeconds === false ? false : null,
-			tagCount: tags.length,
-			tagHash: tags.length > 0 ? fnv1a64(JSON.stringify(tags)) : null
-		});
 		const cacheKey = `${UNSTABLE_CACHE_KEY_PREFIX}:${await sha256Hex(invocationKey)}`;
 		const isDraftMode = isDraftModeEnabled();
-		if (!isDraftMode && !isNestedUnstableCacheCall()) {
+		let staleEntry;
+		if (!isDraftMode && !isNestedUnstableCacheCall() && !_isOnDemandRevalidate()) {
 			const softTags = getCurrentFetchSoftTags();
 			const existing = _hasPendingRevalidatedTag([...tags, ...softTags]) ? null : await getDataCacheHandler().get(cacheKey, {
 				kind: "FETCH",
@@ -457,10 +454,11 @@ function unstable_cache(fn, keyParts, options) {
 			});
 			if (existing?.value && existing.value.kind === "FETCH") {
 				const cached = tryDeserializeUnstableCacheResult(existing.value.data.body);
+				if (existing.cacheState === "stale") staleEntry = existing;
 				if (cached.ok) {
 					if (existing.cacheState === "stale") {
 						if (shouldServeStaleUnstableCacheEntry()) {
-							scheduleUnstableCacheBackgroundRevalidation(cacheKey, () => refreshUnstableCacheResult(fn, args, keyedArgs, cacheKey, tags, revalidateSeconds));
+							scheduleUnstableCacheBackgroundRevalidation(cacheKey, () => refreshUnstableCacheResult(fn, args, keyedArgs, cacheKey, tags, revalidateSeconds, staleEntry));
 							return cached.value;
 						}
 					} else return cached.value;
@@ -468,9 +466,9 @@ function unstable_cache(fn, keyParts, options) {
 			}
 		}
 		if (isDraftMode) return await _unstableCacheAls.run(true, () => fn(...args));
-		return await refreshUnstableCacheResult(fn, args, keyedArgs, cacheKey, tags, revalidateSeconds);
+		return await refreshUnstableCacheResult(fn, args, keyedArgs, cacheKey, tags, revalidateSeconds, staleEntry);
 	};
 	return cachedFn;
 }
 //#endregion
-export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, MemoryCacheHandler, NoOpCacheHandler, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLife, cacheLifeProfiles, cacheTag, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, io, isInsideUnstableCacheScope, markActionRevalidation, unstable_noStore as noStore, unstable_noStore, recordUnstableCacheObservation, refresh, registerDataCacheHandler, registerLazyDataCacheHandler, revalidatePath, revalidateTag, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry, unstable_cache, unstable_cacheLife, unstable_cacheTag, unstable_io, updateTag };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, MemoryCacheHandler, NoOpCacheHandler, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _isOnDemandRevalidate, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLife, cacheLifeProfiles, cacheTag, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, io, isInsideUnstableCacheScope, markActionRevalidation, unstable_noStore as noStore, unstable_noStore, refresh, registerDataCacheHandler, registerLazyDataCacheHandler, revalidatePath, revalidateTag, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry, unstable_cache, unstable_cacheLife, unstable_cacheTag, unstable_io, updateTag };

package/dist/shims/cacheability-classification.d.ts

@@ -17,6 +17,8 @@ export type RouteCacheabilityOutcome = {
    */
   status?: number;
   headers?: Readonly<Record<string, string>>;
+  /** App pages: the client-router stale time from the completed render's cacheLife. */
+  staleTimeSeconds?: number;
   tags?: readonly string[];
 };
 export type RouteCacheabilityState = {

package/dist/shims/caught-not-found-boundaries.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+//#region src/shims/caught-not-found-boundaries.d.ts
+export declare const CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL = "__VINEXT_CAUGHT_NOT_FOUND__";
+/** The boundaries that caught, and those of them the document rendered. */
+export type CaughtNotFoundBoundaries = {
+  ids: ReadonlySet<string>;
+  rendered: Set<string>;
+};
+export declare const CaughtNotFoundBoundariesContext: React.Context<CaughtNotFoundBoundaries | null> | null;
+export declare function withCaughtNotFoundBoundaries(boundaries: CaughtNotFoundBoundaries, children: React.ReactElement): React.ReactElement;
+/** Whether the boundary with this id caught a notFound() in the document. */
+export declare function useCaughtNotFoundBoundary(id: string | undefined): boolean;
+/** A hydrated boundary consumes its id, so a later mount renders its children. */
+export declare function consumeCaughtNotFoundBoundary(id: string | undefined): void;
+//#endregion

package/dist/shims/caught-not-found-boundaries.js

@@ -0,0 +1,48 @@
+import React from "react";
+//#region src/shims/caught-not-found-boundaries.ts
+/**
+* The parallel slot not-found boundaries that caught a slot's notFound() in
+* the document. Fizz has no error boundaries, so a slot page's notFound()
+* rejects the shell; the App Router SSR entry then renders the document again
+* from the same Flight payload, with the boundaries that would have caught it
+* on the client rendering their fallback (Next.js renders them in the browser
+* after an empty error shell). The browser reads the same ids from
+* `self.__VINEXT_CAUGHT_NOT_FOUND__`, so those boundaries hydrate caught. Only
+* the boundaries the document rendered are sent, since one inside another
+* caught boundary never mounts to consume its id.
+*
+* Stored on a global symbol so duplicate module instances share one context,
+* and null in react-server, which has no createContext.
+*/
+const CAUGHT_NOT_FOUND_BOUNDARIES_CONTEXT_KEY = Symbol.for("vinext.caughtNotFoundBoundariesContext");
+const CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL = "__VINEXT_CAUGHT_NOT_FOUND__";
+function getCaughtNotFoundBoundariesContext() {
+	if (typeof React.createContext !== "function") return null;
+	const globalState = globalThis;
+	globalState[CAUGHT_NOT_FOUND_BOUNDARIES_CONTEXT_KEY] ??= React.createContext(null);
+	return globalState[CAUGHT_NOT_FOUND_BOUNDARIES_CONTEXT_KEY];
+}
+const CaughtNotFoundBoundariesContext = getCaughtNotFoundBoundariesContext();
+function withCaughtNotFoundBoundaries(boundaries, children) {
+	return CaughtNotFoundBoundariesContext ? React.createElement(CaughtNotFoundBoundariesContext.Provider, { value: boundaries }, children) : children;
+}
+/** Whether the boundary with this id caught a notFound() in the document. */
+function useCaughtNotFoundBoundary(id) {
+	const serverBoundaries = React.useContext(CaughtNotFoundBoundariesContext);
+	if (id === void 0) return false;
+	if (typeof window === "undefined") {
+		if (serverBoundaries?.ids.has(id) !== true) return false;
+		serverBoundaries.rendered.add(id);
+		return true;
+	}
+	return globalThis[CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL]?.includes(id) === true;
+}
+/** A hydrated boundary consumes its id, so a later mount renders its children. */
+function consumeCaughtNotFoundBoundary(id) {
+	if (id === void 0 || typeof window === "undefined") return;
+	const ids = globalThis[CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL];
+	const index = ids?.indexOf(id) ?? -1;
+	if (index !== -1) ids.splice(index, 1);
+}
+//#endregion
+export { CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL, CaughtNotFoundBoundariesContext, consumeCaughtNotFoundBoundary, useCaughtNotFoundBoundary, withCaughtNotFoundBoundaries };

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

@@ -32,6 +32,12 @@ export type CdnCacheableHeaderInput = {
    */
   tags?: readonly string[];
 };
+/** A page's document, rendered from an RSC request's payload. */
+export type CdnAppPageDocument = {
+  html: string;
+  /** The renderer's own `Link` header. */
+  linkHeader?: string;
+};
 export type CdnResponsePolicy = {
   /** Whether a provider-specific response header controls shared caching. */
   isHeader(name: string): boolean;
@@ -76,12 +82,15 @@ export type CdnCacheAdapter = {
    */
   readonly requiresCompletedResponseAdmission?: boolean;
   /**
-   * This adapter's response-stage transport keys shared App page dispatches by
-   * `VinextResponseStageDispatchOptions.cacheIdentity` when core supplies one.
-   * Core supplies it only when completed-response admission is also required,
-   * because that admission is what makes a query-free identity safe.
+   * This adapter's response-stage transport keys shared dispatches by
+   * `VinextResponseStageDispatchOptions.cacheIdentity` when core supplies
+   * one. Core supplies it only when completed-response admission is also
+   * required, because that admission is what makes a host-free identity, and
+   * a page's query-free one, safe. `"query-free"` also drops the user query
+   * from App page identities; `"host-free"` keeps every dispatch's query, for
+   * a transport whose cache keys the dispatched query itself.
    */
-  readonly responseStageCacheIdentity?: "query-free";
+  readonly responseStageCacheIdentity?: "host-free" | "query-free";
   /**
    * Optionally return a foreground page response while completed-response
    * admission continues on an independent body branch. Returning `null` keeps
@@ -90,6 +99,14 @@ export type CdnCacheAdapter = {
   deferCompletedPageResponseAdmission?(response: Response, complete: (response: Response) => Promise<Response>): Response | null;
   /** Capture the full-route RSC side stream while admitting a completed HTML response. */
   captureAppPageRscData?(rscData: Promise<ArrayBuffer>): void;
+  /**
+   * Store the page's document beside an RSC request's completed response, as
+   * Next.js keeps a page's document and RSC payload in one entry. Returns the
+   * callback admission calls with the document the render rendered from its
+   * payload, or with `null` when the page has no document to store, or
+   * `undefined` when this render's response stores no document.
+   */
+  captureAppPageDocument?(): ((document: CdnAppPageDocument | null) => void) | undefined;
   /**
    * Whether this adapter sends the 304 for a Pages render whose If-None-Match
    * matches. When it does, the render returns the page, so an adapter that

package/dist/shims/cdn-purge-routes.d.ts

@@ -21,4 +21,5 @@ export declare function registerCdnPurgeRoutes(routes: CdnPurgeRoutes): void;
  * also the `/docs` page tag) always purge.
  */
 export declare function isPathKnownNotEdgeCached(path: string): boolean;
-//#endregion
+//#endregion
+export {};