vinext 1.0.0-beta.8 → 1.0.0

package/dist/shims/cache-runtime.js

@@ -1,12 +1,16 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
 import { VINEXT_RSC_MARKER_HEADER } from "../server/headers.js";
+import { workUnitAsyncStorage } from "./internal/work-unit-async-storage.js";
+import { isRouteCacheabilityProbe, recordRouteCacheabilityProbeBailout } from "./cacheability-classification.js";
 import { getDataCacheHandler } from "./cache-handler.js";
-import { trackPprFallbackShellCacheTask } from "./ppr-fallback-shell.js";
-import { isDraftModeEnabled, markDynamicUsage } from "./headers.js";
+import { suppressHangingPromiseAbortRejections } from "./internal/make-hanging-promise.js";
+import { createPprFallbackShellSuspensePromise, trackPprFallbackShellCacheTask } from "./ppr-fallback-shell.js";
+import { isDraftModeEnabled, markDynamicUsage, throwIfInsideCacheScope } from "./headers.js";
 import { _hasPendingRevalidatedTag, _registerCacheContextAccessor, _setRequestScopedCacheLife, cacheLifeProfiles } from "./cache-request-state.js";
 import { addCollectedRequestTags, getCurrentFetchSoftTags } from "./fetch-cache.js";
-import { isMarkedAppPagePropsObject, markAppPagePropsForUseCache } from "./internal/app-page-props-cache-key.js";
+import { makeThenableParams } from "./thenable-params.js";
+import { APP_PAGE_USE_CACHE_MARKER, hasUseCachePageMarker, isMarkedAppPagePropsObject, isUseCacheFunctionReference, markAppPagePropsForUseCache } from "./internal/app-page-props-cache-key.js";
 import { getCurrentRootParams } from "./root-params.js";
 //#region src/shims/cache-runtime.ts
 /**
@@ -77,6 +81,7 @@ function getNestedCacheShortExpireErrorMessage() {
 	return `A "use cache" with short \`expire\` (under 5 minutes) is nested inside another "use cache" that has no explicit \`cacheLife\`, which is not allowed ${nestedCacheContextPhrase()}. Add \`cacheLife()\` to the outer "use cache" to choose whether it should be prerendered (with longer \`expire\`) or remain dynamic (with short \`expire\`). Read more: https://nextjs.org/docs/messages/nested-use-cache-no-explicit-cachelife`;
 }
 const cacheContextStorage = getOrCreateAls("vinext.cacheRuntime.contextAls");
+const unstableCacheContextStorage = getOrCreateAls("vinext.unstableCache.als");
 _registerCacheContextAccessor(() => cacheContextStorage.getStore() ?? null);
 /**
 * Get the current cache context. Returns null if not inside a "use cache" function.
@@ -305,127 +310,177 @@ function propagateRootParamNamesToParent(names) {
 */
 function registerCachedFunction(fn, id, variant, options = {}) {
 	const cacheVariant = variant ?? "";
-	const omitAppPageSearchParamsFromFirstArg = options.appPageDefaultExport === true;
+	const omitAppPageSearchParams = cacheVariant !== "private";
+	const cacheFunctionId = options.serverReferenceId ? JSON.stringify([id, options.serverReferenceId]) : id;
 	const isDev = typeof process !== "undefined" && process.env.NODE_ENV === "development";
-	const cachedFn = (...args) => trackPprFallbackShellCacheTask(async () => {
-		const rsc = await getRscModule();
-		const keySeed = getUseCacheKeySeed();
-		const captures = options.decryptCaptures ? await options.decryptCaptures(args[0]) : void 0;
-		const hasCaptureEnvelope = captures !== void 0;
-		const admittedArgs = options.argumentCount === void 0 ? args : hasCaptureEnvelope ? [args[0], ...args.slice(1, 1 + options.argumentCount)] : args.slice(0, options.argumentCount);
-		const executionArgs = hasCaptureEnvelope ? [captures, ...admittedArgs.slice(1)] : admittedArgs;
-		const callArgs = executionArgs;
-		let cacheKey;
-		try {
-			const processedArgs = executionArgs.length > 0 ? unwrapThenableObjectArray(executionArgs, { omitAppPageSearchParamsFromFirstArg }) : [];
-			if (rsc && executionArgs.length > 0) {
-				const tempRefs = rsc.createClientTemporaryReferenceSet();
-				cacheKey = buildUseCacheKey(id, keySeed, await replyToCacheKey(await rsc.encodeReply(processedArgs, { temporaryReferences: tempRefs })));
-			} else cacheKey = buildUseCacheKey(id, keySeed, processedArgs.length > 0 ? stableStringify(processedArgs) : void 0);
-		} catch {
-			return fn(...callArgs);
-		}
+	const cachedFn = (...args) => {
 		if (cacheVariant === "private") {
 			const parentCtx = cacheContextStorage.getStore();
 			if (parentCtx && parentCtx.variant !== "private") throwPrivateUseCacheInsidePublicUseCacheError();
-			if (typeof process !== "undefined" && process.env.VINEXT_PRERENDER === "1") markDynamicUsage();
-			const privateCache = _getPrivateState()._privateCache;
-			const privateHit = privateCache.get(cacheKey);
-			if (privateHit !== void 0) return privateHit;
-			const execution = await executeWithContext(fn, callArgs, cacheVariant, rsc);
-			if (execution.cacheable) privateCache.set(cacheKey, execution.result);
-			return execution.result;
-		}
-		if (isDev || isDraftModeEnabled()) return (await executeWithContext(fn, callArgs, cacheVariant, rsc)).result;
-		const handler = getDataCacheHandler();
-		const rootParams = getCurrentRootParams();
-		const knownRootParamNames = knownRootParamsByFunctionId.get(id);
-		const coarseCacheKey = cacheKey;
-		if (knownRootParamNames && rootParams) cacheKey += computeRootParamsCacheKeySuffix(rootParams, knownRootParamNames);
-		const softTags = getCurrentFetchSoftTags();
-		let existing = null;
-		if (!_hasPendingRevalidatedTag(softTags)) try {
-			existing = await handler.get(cacheKey, {
-				kind: "FETCH",
-				softTags
-			});
-		} catch (error) {
-			console.error("[vinext] use cache: handler.get failed; treating as a cache miss:", error);
+			if (unstableCacheContextStorage.getStore() === true) throwPrivateUseCacheInsideUnstableCacheError();
+			markDynamicUsage();
+			const expression = "\"use cache: private\"";
+			const workUnit = workUnitAsyncStorage.getStore();
+			if (workUnit?.type === "prerender" || workUnit?.type === "prerender-client" || workUnit?.type === "prerender-runtime") {
+				if (isRouteCacheabilityProbe()) recordRouteCacheabilityProbeBailout("private-cache", {
+					cacheable: false,
+					dynamicUsage: true,
+					reason: `${expression} requires request-time execution`
+				});
+				suppressHangingPromiseAbortRejections(workUnit.renderSignal);
+				workUnit.signalPrerenderBailout?.(expression);
+				return new Promise(() => {});
+			}
+			const fallbackShellPromise = createPprFallbackShellSuspensePromise(expression);
+			if (fallbackShellPromise) return fallbackShellPromise;
+			if (isRouteCacheabilityProbe()) {
+				recordRouteCacheabilityProbeBailout("private-cache", {
+					cacheable: false,
+					dynamicUsage: true,
+					classificationFailure: true,
+					reason: `${expression} probe was not running in a prerender work unit`
+				});
+				return new Promise(() => {});
+			}
 		}
-		const redirectValue = existing?.value;
-		if (isRootParamRedirect(existing) && existing?.cacheState !== "stale" && rootParams && redirectValue?.kind === "FETCH" && !_hasPendingRevalidatedTag([...redirectValue.tags ?? [], ...softTags])) {
-			cacheKey = coarseCacheKey + computeRootParamsCacheKeySuffix(rootParams, addKnownRootParamNames(id, rootParamNamesFromTags(redirectValue.tags)));
+		return trackPprFallbackShellCacheTask(async () => {
+			const rsc = await getRscModule();
+			const keySeed = getUseCacheKeySeed();
+			const captures = options.decryptCaptures ? await options.decryptCaptures(args[0]) : void 0;
+			const hasCaptureEnvelope = captures !== void 0;
+			const pagePropsArgIndex = args.findIndex(hasUseCachePageMarker);
+			const isPageInvocation = pagePropsArgIndex !== -1;
+			const invocationArgs = isPageInvocation ? replaceArgument(args, pagePropsArgIndex, withoutUseCachePageMarker(args[pagePropsArgIndex])) : args;
+			const admittedArgs = options.argumentCount === void 0 ? invocationArgs : hasCaptureEnvelope ? [invocationArgs[0], ...invocationArgs.slice(1, 1 + options.argumentCount)] : invocationArgs.slice(0, options.argumentCount);
+			const executionArgs = hasCaptureEnvelope ? [captures, ...admittedArgs.slice(1)] : admittedArgs;
+			const pagePropsIndex = omitAppPageSearchParams && isPageInvocation ? pagePropsArgIndex : void 0;
+			const callArgs = pagePropsIndex === void 0 ? executionArgs : withErroringPageSearchParams(executionArgs, pagePropsIndex);
+			let cacheKey;
 			try {
+				const processedArgs = executionArgs.length > 0 ? unwrapThenableObjectArray(executionArgs, {
+					pagePropsIndex,
+					omitMarkedAppPageSearchParams: omitAppPageSearchParams
+				}) : [];
+				if (rsc && executionArgs.length > 0) {
+					const tempRefs = rsc.createClientTemporaryReferenceSet();
+					const encoded = await rsc.encodeReply(processedArgs, { temporaryReferences: tempRefs });
+					cacheKey = buildUseCacheKey(cacheFunctionId, keySeed, await replyToCacheKey(encoded));
+				} else {
+					const argsKey = processedArgs.length > 0 ? stableStringify(processedArgs) : void 0;
+					cacheKey = buildUseCacheKey(cacheFunctionId, keySeed, argsKey);
+				}
+			} catch {
+				return (await executeWithContext(fn, callArgs, cacheVariant)).result;
+			}
+			if (cacheVariant === "private") {
+				const privateCache = _getPrivateState()._privateCache;
+				const privateHit = privateCache.get(cacheKey);
+				if (privateHit !== void 0) return privateHit;
+				const execution = await executeWithContext(fn, callArgs, cacheVariant, rsc);
+				if (execution.cacheable) privateCache.set(cacheKey, execution.result);
+				return execution.result;
+			}
+			if (isDev || isDraftModeEnabled()) return (await executeWithContext(fn, callArgs, cacheVariant, rsc)).result;
+			const handler = getDataCacheHandler();
+			const rootParams = getCurrentRootParams();
+			const knownRootParamNames = knownRootParamsByFunctionId.get(id);
+			const coarseCacheKey = cacheKey;
+			if (knownRootParamNames && rootParams) cacheKey += computeRootParamsCacheKeySuffix(rootParams, knownRootParamNames);
+			const softTags = getCurrentFetchSoftTags();
+			let existing = null;
+			if (!_hasPendingRevalidatedTag(softTags)) try {
 				existing = await handler.get(cacheKey, {
 					kind: "FETCH",
 					softTags
 				});
 			} catch (error) {
 				console.error("[vinext] use cache: handler.get failed; treating as a cache miss:", error);
-				existing = null;
 			}
-		}
-		if (existing?.value && existing.value.kind === "FETCH" && existing.cacheState !== "stale" && !_hasPendingRevalidatedTag([...existing.value.tags ?? [], ...softTags])) try {
-			propagateRootParamNamesToParent(knownRootParamsByFunctionId.get(id));
-			propagateCacheTagsToRequest(existing.value.tags);
-			if (rsc && existing.value.data.headers["x-vinext-rsc"] === "1") {
-				const stream = uint8ToStream(base64ToUint8(existing.value.data.body));
-				const result = await rsc.createFromReadableStream(stream, {}, { preserveServerReferences: true });
-				recordRequestScopedCacheControl(existing.cacheControl);
-				return result;
+			const redirectValue = existing?.value;
+			if (isRootParamRedirect(existing) && existing?.cacheState !== "stale" && rootParams && redirectValue?.kind === "FETCH" && !_hasPendingRevalidatedTag([...redirectValue.tags ?? [], ...softTags])) {
+				cacheKey = coarseCacheKey + computeRootParamsCacheKeySuffix(rootParams, addKnownRootParamNames(id, rootParamNamesFromTags(redirectValue.tags)));
+				try {
+					existing = await handler.get(cacheKey, {
+						kind: "FETCH",
+						softTags
+					});
+				} catch (error) {
+					console.error("[vinext] use cache: handler.get failed; treating as a cache miss:", error);
+					existing = null;
+				}
 			}
-			const result = JSON.parse(existing.value.data.body);
-			recordRequestScopedCacheControl(existing.cacheControl);
-			return result;
-		} catch {}
-		const { result, ctx, effectiveLife, collectedResult } = await runCachedFunctionWithContext(fn, callArgs, cacheVariant, (value) => serializeCacheResult(value, rsc));
-		const rootParamNames = ctx.readRootParamNames && ctx.readRootParamNames.size > 0 ? addKnownRootParamNames(id, ctx.readRootParamNames) : knownRootParamsByFunctionId.get(id);
-		recordRequestScopedCacheLife(effectiveLife);
-		propagateCacheTagsToRequest(ctx.tags);
-		const revalidateSeconds = effectiveLife.revalidate ?? cacheLifeProfiles.default.revalidate ?? 900;
-		if (collectedResult?.cacheEntry) try {
-			const serialized = collectedResult.cacheEntry;
-			const cacheValue = {
-				kind: "FETCH",
-				data: {
-					headers: serialized.headers,
-					body: serialized.body,
-					url: cacheKey
-				},
-				tags: ctx.tags,
-				revalidate: revalidateSeconds
-			};
-			const cacheContext = {
-				fetchCache: true,
-				tags: ctx.tags,
-				cacheControl: {
-					revalidate: revalidateSeconds,
-					expire: effectiveLife.expire,
-					stale: effectiveLife.stale
+			if (existing?.value && existing.value.kind === "FETCH" && existing.cacheState !== "stale" && !_hasPendingRevalidatedTag([...existing.value.tags ?? [], ...softTags])) try {
+				propagateRootParamNamesToParent(knownRootParamsByFunctionId.get(id));
+				propagateCacheTagsToRequest(existing.value.tags);
+				if (rsc && existing.value.data.headers["x-vinext-rsc"] === "1") {
+					const stream = uint8ToStream(base64ToUint8(existing.value.data.body));
+					const result = await rsc.createFromReadableStream(stream, {}, { preserveServerReferences: true });
+					recordRequestScopedCacheControl(existing.cacheControl);
+					return result;
 				}
-			};
-			if (rootParamNames && rootParamNames.size > 0 && rootParams) {
-				const specificCacheKey = coarseCacheKey + computeRootParamsCacheKeySuffix(rootParams, rootParamNames);
-				const redirectTags = [...ctx.tags, ...[...rootParamNames].map((name) => ROOT_PARAM_TAG_PREFIX + name)];
-				await handler.set(coarseCacheKey, {
+				const result = JSON.parse(existing.value.data.body);
+				recordRequestScopedCacheControl(existing.cacheControl);
+				return result;
+			} catch {}
+			const { result, ctx, effectiveLife, collectedResult } = await runCachedFunctionWithContext(fn, callArgs, cacheVariant, (value) => serializeCacheResult(value, rsc));
+			const rootParamNames = ctx.readRootParamNames && ctx.readRootParamNames.size > 0 ? addKnownRootParamNames(id, ctx.readRootParamNames) : knownRootParamsByFunctionId.get(id);
+			recordRequestScopedCacheLife(effectiveLife);
+			propagateCacheTagsToRequest(ctx.tags);
+			const revalidateSeconds = effectiveLife.revalidate ?? cacheLifeProfiles.default.revalidate ?? 900;
+			if (collectedResult?.cacheEntry) try {
+				let cacheFunctionInvocation;
+				if (options.serverReferenceId && options.encodeInvocationArgs) try {
+					cacheFunctionInvocation = {
+						encryptedArgs: await options.encodeInvocationArgs(pagePropsIndex === void 0 ? admittedArgs : toReplayablePageArgs(admittedArgs, pagePropsIndex)),
+						referenceId: options.serverReferenceId,
+						rootParams: Object.fromEntries(Object.entries(rootParams ?? {}).filter((entry) => entry[1] !== void 0)),
+						softTags
+					};
+				} catch {}
+				const serialized = collectedResult.cacheEntry;
+				const cacheValue = {
 					kind: "FETCH",
 					data: {
-						headers: { [ROOT_PARAM_REDIRECT_HEADER]: "1" },
-						body: "",
-						url: coarseCacheKey
+						headers: serialized.headers,
+						body: serialized.body,
+						url: cacheKey
 					},
-					tags: redirectTags,
+					tags: ctx.tags,
 					revalidate: revalidateSeconds
-				}, {
-					...cacheContext,
-					tags: redirectTags
-				});
-				cacheValue.data.url = specificCacheKey;
-				await handler.set(specificCacheKey, cacheValue, cacheContext);
-			} else await handler.set(cacheKey, cacheValue, cacheContext);
-		} catch {}
-		return collectedResult ? collectedResult.result : result;
-	}, cacheVariant);
+				};
+				const cacheContext = {
+					fetchCache: true,
+					tags: ctx.tags,
+					...cacheFunctionInvocation ? { cacheFunctionInvocation } : {},
+					cacheControl: {
+						revalidate: revalidateSeconds,
+						expire: effectiveLife.expire,
+						stale: effectiveLife.stale
+					}
+				};
+				if (rootParamNames && rootParamNames.size > 0 && rootParams) {
+					const specificCacheKey = coarseCacheKey + computeRootParamsCacheKeySuffix(rootParams, rootParamNames);
+					const redirectTags = [...ctx.tags, ...[...rootParamNames].map((name) => ROOT_PARAM_TAG_PREFIX + name)];
+					await handler.set(coarseCacheKey, {
+						kind: "FETCH",
+						data: {
+							headers: { [ROOT_PARAM_REDIRECT_HEADER]: "1" },
+							body: "",
+							url: coarseCacheKey
+						},
+						tags: redirectTags,
+						revalidate: revalidateSeconds
+					}, {
+						...cacheContext,
+						tags: redirectTags
+					});
+					cacheValue.data.url = specificCacheKey;
+					await handler.set(specificCacheKey, cacheValue, cacheContext);
+				} else await handler.set(cacheKey, cacheValue, cacheContext);
+			} catch {}
+			return collectedResult ? collectedResult.result : result;
+		}, cacheVariant);
+	};
 	Object.defineProperty(cachedFn, "length", {
 		value: fn.length,
 		configurable: true
@@ -438,12 +493,22 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 const USE_CACHE_FUNCTION_SYMBOL = Symbol.for("vinext.useCacheFunction");
 /** @internal Symbol carrying transform-derived cached function argument metadata. */
 const USE_CACHE_ACCEPTS_SECOND_ARGUMENT_SYMBOL = Symbol.for("vinext.useCacheAcceptsSecondArgument");
+/** Whether a loaded server reference is a transformed `"use cache"` function. */
+function isUseCacheFunction(value) {
+	return isUseCacheFunctionReference(value);
+}
 function throwPrivateUseCacheInsidePublicUseCacheError() {
 	const error = /* @__PURE__ */ new Error("\"use cache: private\" must not be used within \"use cache\". It can only be nested inside of another \"use cache: private\".");
 	const ctx = getRequestContext();
 	if (ctx) ctx.invalidDynamicUsageError = error;
 	throw error;
 }
+function throwPrivateUseCacheInsideUnstableCacheError() {
+	const error = /* @__PURE__ */ new Error("\"use cache: private\" must not be used within `unstable_cache()`.");
+	const ctx = getRequestContext();
+	if (ctx) ctx.invalidDynamicUsageError = error;
+	throw error;
+}
 function recordRequestScopedCacheControl(cacheControl) {
 	if (cacheControl === void 0) return;
 	const life = {
@@ -513,11 +578,12 @@ async function runCachedFunctionWithContext(fn, args, variant, collectResult) {
 		invalidDynamicUsageError: void 0
 	};
 	let collectedResult;
-	const result = await cacheContextStorage.run(ctx, async () => {
+	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 (ctx.invalidDynamicUsageError) throw ctx.invalidDynamicUsageError;
 	const effectiveLife = resolveCacheLife(ctx.lifeConfigs);
 	if (parentCtx) {
@@ -537,27 +603,79 @@ async function runCachedFunctionWithContext(fn, args, variant, collectResult) {
 		collectedResult
 	};
 }
-function unwrapThenableObjects(value, options = {}) {
+function unwrapThenableObjects(value, options) {
 	if (value === null || value === void 0 || typeof value !== "object") return value;
-	if (Array.isArray(value)) return value.map((item) => unwrapThenableObjects(item));
-	if (typeof value.then === "function") {
-		const keys = Object.keys(value);
-		if (keys.length > 0) {
-			const plain = {};
-			for (const key of keys) plain[key] = unwrapThenableObjects(value[key]);
-			return plain;
-		}
-		return value;
+	const childOptions = { omitMarkedAppPageSearchParams: options.omitMarkedAppPageSearchParams };
+	if (Array.isArray(value)) return value.map((item) => unwrapThenableObjects(item, childOptions));
+	if (isThenableObject(value)) {
+		const plain = {};
+		for (const key of Object.keys(value)) plain[key] = unwrapThenableObjects(value[key], childOptions);
+		return plain;
 	}
+	if (typeof value.then === "function") return value;
 	const result = {};
 	for (const key of Object.keys(value)) {
-		if (key === "searchParams" && (options.omitAppPageSearchParamsAtRoot || isMarkedAppPagePropsObject(value))) continue;
-		result[key] = unwrapThenableObjects(value[key]);
+		if (key === "searchParams" && (options.omitAppPageSearchParamsAtRoot || options.omitMarkedAppPageSearchParams && isMarkedAppPagePropsObject(value))) continue;
+		result[key] = unwrapThenableObjects(value[key], childOptions);
 	}
 	return result;
 }
+/**
+* A thenable (not an array) with own enumerable properties — the
+* `Object.assign(Promise.resolve(obj), obj)` pattern Next.js params use. The
+* cache key is built from its fields instead of the promise.
+*/
+function isThenableObject(value) {
+	return !Array.isArray(value) && "then" in value && typeof value.then === "function" && Object.keys(value).length > 0;
+}
+function isPagePropsObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function replaceArgument(args, index, value) {
+	const result = [...args];
+	result[index] = value;
+	return result;
+}
+/** Remove the `$$isPage` invocation marker before props reach the key or user code. */
+function withoutUseCachePageMarker(props) {
+	const { [APP_PAGE_USE_CACHE_MARKER]: _marker, ...pageProps } = props;
+	return isMarkedAppPagePropsObject(props) ? markAppPagePropsForUseCache(pageProps) : pageProps;
+}
+/**
+* Response Store replay args for a public page cache: drop `searchParams` from
+* the page props at `index` (after a capture envelope, if any), as Next.js does
+* for the serialized arguments (use-cache-wrapper.ts, `isPageSegmentFunction`),
+* and keep the `$$isPage` marker so a replay regains page semantics, including
+* the erroring searchParams fallback.
+*/
+function toReplayablePageArgs(args, index) {
+	const props = args[index];
+	if (!isPagePropsObject(props)) return [...args];
+	const { searchParams: _searchParams, ...pageProps } = props;
+	return replaceArgument(args, index, {
+		...pageProps,
+		[APP_PAGE_USE_CACHE_MARKER]: true
+	});
+}
+/**
+* Give page props at `index` without `searchParams` (a Response Store replay of
+* args encoded by `toReplayablePageArgs`) a value that throws on
+* access inside the cache scope, like Next.js's
+* `makeErroringSearchParamsForUseCache`, instead of `undefined`.
+*/
+function withErroringPageSearchParams(args, index) {
+	const props = args[index];
+	if (!isPagePropsObject(props) || "searchParams" in props) return args;
+	return replaceArgument(args, index, {
+		...props,
+		searchParams: makeThenableParams({}, { observeParamAccess: () => throwIfInsideCacheScope("searchParams") })
+	});
+}
 function unwrapThenableObjectArray(values, options) {
-	return values.map((value, index) => unwrapThenableObjects(value, { omitAppPageSearchParamsAtRoot: index === 0 && options.omitAppPageSearchParamsFromFirstArg }));
+	return values.map((value, index) => unwrapThenableObjects(value, {
+		omitAppPageSearchParamsAtRoot: index === options.pagePropsIndex,
+		omitMarkedAppPageSearchParams: options.omitMarkedAppPageSearchParams
+	}));
 }
 function stableStringify(value, seen) {
 	if (value === void 0) return "undefined";
@@ -584,4 +702,4 @@ function stableStringify(value, seen) {
 	return JSON.stringify(value);
 }
 //#endregion
-export { NestedDynamicUseCacheError, buildUseCacheKey, cacheContextStorage, clearPrivateCache, getCacheContext, markAppPagePropsForUseCache, registerCachedFunction, replyToCacheKey, runWithPrivateCache };
+export { NestedDynamicUseCacheError, buildUseCacheKey, cacheContextStorage, clearPrivateCache, getCacheContext, isThenableObject, isUseCacheFunction, markAppPagePropsForUseCache, registerCachedFunction, replyToCacheKey, runWithPrivateCache };

package/dist/shims/cache.d.ts

@@ -1,6 +1,6 @@
 import { ExecutionContextLike, getRequestExecutionContext, runWithExecutionContext } from "./request-context.js";
 import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheLifeConfig, CacheState, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
-import { CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, setCacheHandler, setDataCacheHandler } from "./cache-handler.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";
 //#region src/shims/cache.d.ts
 /**
  * Revalidate cached data associated with a specific cache tag.
@@ -15,7 +15,7 @@ import { CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerVa
  * @param tag - Cache tag to revalidate
  * @param profile - cacheLife profile name (e.g. 'max', 'hours') or inline { expire: number }
  */
-declare function revalidateTag(tag: string, profile?: string | {
+export declare function revalidateTag(tag: string, profile?: string | {
   expire?: number;
 }): undefined;
 /**
@@ -33,7 +33,7 @@ declare function revalidateTag(tag: string, profile?: string | {
  * The `type` parameter is App Router only — Pages Router does not generate
  * layout/page hierarchy tags, so only no-type invalidation applies there.
  */
-declare function revalidatePath(path: string, type?: "page" | "layout"): undefined;
+export declare function revalidatePath(path: string, type?: "page" | "layout"): undefined;
 /**
  * No-op shim for API compatibility.
  *
@@ -42,7 +42,7 @@ declare function revalidatePath(path: string, type?: "page" | "layout"): undefin
  * vinext reports the dynamic-only invalidation through the Server Action
  * response header that the client router already understands.
  */
-declare function refresh(): void;
+export declare function refresh(): void;
 /**
  * Expire a cache tag immediately (Next.js 16).
  *
@@ -56,7 +56,7 @@ declare function refresh(): void;
  *
  * @see https://nextjs.org/docs/app/api-reference/functions/updateTag
  */
-declare function updateTag(tag: string): undefined;
+export declare function updateTag(tag: string): undefined;
 /**
  * Opt out of static rendering and indicate a particular component should not be cached.
  *
@@ -65,7 +65,7 @@ declare function updateTag(tag: string): undefined;
  * 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.
  */
-declare function unstable_noStore(): void;
+export declare function unstable_noStore(): void;
 /**
  * Marks an IO boundary in server components by returning a resolved promise
  * during requests and a hanging promise during prerendering.
@@ -89,13 +89,13 @@ declare function unstable_noStore(): void;
  * When no work unit store is present (e.g. client-side, standalone script),
  * resolves immediately — matching the browser/client implementation.
  */
-declare function io(): Promise<void>;
+export declare function io(): Promise<void>;
 /**
  * @deprecated Use `io` instead. Kept as a transitional alias since vinext
  * shipped the unstable name longer than upstream Next.js (see #805). Will be
  * removed in a future minor.
  */
-declare function unstable_io(): Promise<void>;
+export declare function unstable_io(): Promise<void>;
 /**
  * Set the cache lifetime for a "use cache" function.
  *
@@ -108,7 +108,7 @@ declare function unstable_io(): Promise<void>;
  *
  * When called outside a "use cache" context, this is a validated no-op.
  */
-declare function cacheLife(profile: string | CacheLifeConfig): void;
+export declare function cacheLife(profile: string | CacheLifeConfig): void;
 /**
  * Tag a "use cache" function's cached result for on-demand revalidation.
  *
@@ -120,15 +120,15 @@ declare function cacheLife(profile: string | CacheLifeConfig): void;
  *
  * When called outside a "use cache" context, this is a no-op.
  */
-declare function cacheTag(...tags: string[]): void;
-declare function unstable_cacheLife(profile: string | CacheLifeConfig): void;
-declare function unstable_cacheTag(...tags: string[]): void;
+export declare function cacheTag(...tags: string[]): void;
+export declare function unstable_cacheLife(profile: string | CacheLifeConfig): void;
+export declare function unstable_cacheTag(...tags: string[]): void;
 /**
  * Check if the current execution context is inside an unstable_cache() callback.
  * Used by headers(), cookies(), and connection() to throw errors when
  * dynamic request APIs are called inside a cache scope.
  */
-declare function isInsideUnstableCacheScope(): boolean;
+export declare function isInsideUnstableCacheScope(): boolean;
 type UnstableCacheOptions = {
   revalidate?: number | false;
   tags?: string[];
@@ -139,6 +139,6 @@ type UnstableCacheOptions = {
  * Returns a new function that caches results. The cache key is derived
  * from keyParts + serialized arguments.
  */
-declare function unstable_cache<T extends (...args: any[]) => Promise<any>>(fn: T, keyParts?: string[], options?: UnstableCacheOptions): T;
+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, CacheState, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, type ExecutionContextLike, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLife, cacheLifeProfiles, cacheTag, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, io, isInsideUnstableCacheScope, markActionRevalidation, unstable_noStore as noStore, unstable_noStore, recordUnstableCacheObservation, refresh, revalidatePath, revalidateTag, 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, ActionRevalidationKind, CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CacheLifeConfig, CacheState, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, type ExecutionContextLike, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, markActionRevalidation, unstable_noStore as noStore, recordUnstableCacheObservation, registerDataCacheHandler, registerLazyDataCacheHandler, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry };