vinext 1.0.1 → 1.1.0

package/dist/shims/cache-callable-runtime.js

@@ -1,190 +1,72 @@
-import { isThenableObject, isUseCacheFunction, registerCachedFunction as registerCachedFunction$1 } from "./cache-runtime.js";
+import { restoreFlightReply, snapshotFlightReply } from "./cache-flight-arguments.js";
+import { isUseCacheFunction, memoizeInCacheScope, registerCachedFunction as registerCachedFunction$1, replayCachedFunction } from "./cache-runtime.js";
 import { decryptActionBoundArgs, encryptActionBoundArgs } from "@vitejs/plugin-rsc/utils/encryption-runtime";
+import { createFromReadableStream, renderToReadableStream } from "@vitejs/plugin-rsc/react/rsc";
 //#region src/shims/cache-callable-runtime.ts
 const CACHE_CAPTURE_TYPE = "use-cache-captures";
-function encryptCacheCaptures(captures) {
-	return {
-		type: CACHE_CAPTURE_TYPE,
-		encrypted: encryptCaptures(captures)
-	};
+async function encryptArguments(value) {
+	return encryptActionBoundArgs(JSON.stringify(value));
+}
+async function decryptArguments(encrypted) {
+	const serialized = await decryptActionBoundArgs(Promise.resolve(encrypted));
+	if (typeof serialized !== "string") throw new Error("Invalid cache function arguments");
+	const value = JSON.parse(serialized);
+	if (value?.version !== 1) throw new Error("Invalid cache function arguments");
+	return value;
 }
-async function decryptCacheCaptures(value) {
-	if (!isCacheCaptureEnvelope(value)) return;
-	return decryptCacheArguments(value.encrypted);
+function encryptCacheCaptures(captures) {
+	return memoizedCaptureEnvelope(...captures);
 }
+const memoizedCaptureEnvelope = memoizeInCacheScope((...captures) => ({
+	type: CACHE_CAPTURE_TYPE,
+	encrypted: encryptCaptures(captures)
+}));
 async function encryptCaptures(captures) {
-	return encryptActionBoundArgs(await encodeCacheArguments(captures, "skip"));
-}
-async function encryptCacheArguments(args) {
-	return encryptActionBoundArgs(await encodeCacheArguments(args));
-}
-async function decryptCacheArguments(encrypted) {
-	return decodeCacheArguments(await decryptActionBoundArgs(Promise.resolve(encrypted)));
-}
-function isThenable(value) {
-	return "then" in value && typeof value.then === "function";
-}
-function isPlainRecord(value) {
-	const prototype = Object.getPrototypeOf(value);
-	return (prototype === Object.prototype || prototype === null) && !("$$typeof" in value);
-}
-/**
-* The arguments hold a getter. Flight reads it again while serializing, and a
-* getter can return a different value, such as a new promise, on every read,
-* so the recorded promise fields may not match what Flight serializes.
-*/
-var UnreplayableCacheArgumentsError = class extends Error {
-	constructor() {
-		super("Cache function arguments with getters cannot be replayed");
-	}
-};
-/**
-* The own entries of `value` that Flight serializes: every index below an
-* array's `length`, including holes and non-enumerable indices, as
-* `JSON.stringify` reads them, and the enumerable own keys of anything else.
-* A getter, own or inherited through an array hole, is never run.
-*/
-function ownEntries(value, getters) {
-	const keys = Array.isArray(value) ? Array.from({ length: value.length }, (_, index) => String(index)) : Object.keys(value);
-	const entries = [];
-	for (const key of keys) {
-		if (readsGetter(value, key)) {
-			if (getters === "reject") throw new UnreplayableCacheArgumentsError();
-			continue;
-		}
-		entries.push([key, Reflect.get(value, key)]);
-	}
-	return entries;
-}
-/**
-* Whether reading `key` from `value` runs a getter. An array hole reads
-* through the prototype chain, which can hold an indexed data property or
-* accessor. A setter-only accessor reads as `undefined` without running code.
-*/
-function readsGetter(value, key) {
-	for (let target = value; target !== null; target = Reflect.getPrototypeOf(target)) {
-		const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-		if (descriptor) return typeof descriptor.get === "function";
-	}
-	return false;
-}
-/** Members of the values Flight serializes recursively, which can hold params. */
-function flightMembers(value, getters) {
-	if (value instanceof Map) return [...value].flat();
-	if (value instanceof Set) return [...value];
-	if (isThenableObject(value) || Array.isArray(value) || isPlainRecord(value)) return ownEntries(value, getters).map(([, member]) => member);
-	return [];
-}
-/**
-* Collect the own fields of every promise-augmented object in the arguments,
-* including ones inside resolved promise values. The arguments are passed to
-* Flight as they are, so Flight keeps their shared references and cycles.
-* With `getters: "reject"`, throws `UnreplayableCacheArgumentsError` when the
-* arguments hold a getter; with `"skip"`, promise fields behind a getter are
-* not recorded.
-*/
-async function encodeCacheArguments(args, getters = "reject") {
-	const settled = /* @__PURE__ */ new Map();
-	for (;;) {
-		const thenableObjects = [];
-		const unsettled = [];
-		const visited = /* @__PURE__ */ new Set();
-		const pending = [args];
-		while (pending.length > 0) {
-			const value = pending.pop();
-			if (typeof value !== "object" || value === null || visited.has(value)) continue;
-			visited.add(value);
-			const children = flightMembers(value, getters);
-			if (isThenableObject(value)) {
-				const fields = Object.fromEntries(ownEntries(value, getters));
-				thenableObjects.push({
-					fields,
-					promise: value
-				});
+	const files = new FormData();
+	let nextFileId = 0;
+	const temporaryReferences = new class extends WeakMap {
+		get(value) {
+			let id = super.get(value);
+			if (id === void 0 && value instanceof File) {
+				id = String(nextFileId++);
+				super.set(value, id);
+				files.append(id, value);
 			}
-			if (isThenable(value)) {
-				const result = settled.get(value);
-				if (!result) unsettled.push(value);
-				else if (result.status === "fulfilled") children.push(result.value);
-			}
-			for (const child of children) pending.push(child);
+			return id;
 		}
-		if (unsettled.length === 0) return {
-			args,
-			thenableObjects
-		};
-		const results = await Promise.allSettled(unsettled);
-		unsettled.forEach((thenable, index) => settled.set(thenable, results[index]));
-	}
-}
-/** Restore the promise fields that `encodeCacheArguments` captured before Flight encoding. */
-function decodeCacheArguments(value) {
-	if (typeof value !== "object" || value === null || !("args" in value) || !Array.isArray(value.args) || !("thenableObjects" in value) || !Array.isArray(value.thenableObjects)) throw new Error("Invalid cache function arguments");
-	adoptFlightThenables(value);
-	for (const thenableObject of value.thenableObjects) {
-		if (!isEncodedThenableObject(thenableObject)) throw new Error("Invalid cache function arguments");
-		Object.assign(thenableObject.promise, thenableObject.fields);
-	}
-	return value.args;
+	}();
+	const stream = renderToReadableStream(captures, { temporaryReferences });
+	const bytes = await new Response(stream).arrayBuffer();
+	return encryptActionBoundArgs(JSON.stringify({
+		version: 1,
+		result: Buffer.from(bytes).toString("base64"),
+		files: await snapshotFlightReply(files)
+	}));
 }
-function isEncodedThenableObject(value) {
-	if (typeof value !== "object" || value === null || !isPlainRecord(value)) return false;
-	const { fields, promise } = value;
-	return typeof fields === "object" && fields !== null && isPlainRecord(fields) && promise instanceof Promise;
-}
-/**
-* Flight decodes promises as React chunks whose own fields are React's
-* internal state. Adopt them into native promises, which have no own fields,
-* so key serialization sees a promise exactly as the original call did.
-* Flight shares one chunk between references to the same promise, so each
-* chunk is adopted once, including references inside resolved values.
-*/
-function adoptFlightThenables(value, adopted = /* @__PURE__ */ new WeakMap()) {
-	if (typeof value !== "object" || value === null) return value;
-	if (adopted.has(value)) return adopted.get(value);
-	if (isThenable(value)) {
-		const promise = Promise.resolve(value).then((resolved) => adoptFlightThenables(resolved, adopted));
-		promise.catch(() => {});
-		adopted.set(value, promise);
-		return promise;
-	}
-	if (value instanceof Map) {
-		adopted.set(value, value);
-		const entries = [...value];
-		value.clear();
-		for (const [key, item] of entries) value.set(adoptFlightThenables(key, adopted), adoptFlightThenables(item, adopted));
-		return value;
-	}
-	if (value instanceof Set) {
-		adopted.set(value, value);
-		const items = [...value];
-		value.clear();
-		for (const item of items) value.add(adoptFlightThenables(item, adopted));
-		return value;
-	}
-	if (!Array.isArray(value) && !isPlainRecord(value)) return value;
-	adopted.set(value, value);
-	for (const key of Object.keys(value)) Reflect.set(value, key, adoptFlightThenables(Reflect.get(value, key), adopted));
-	return value;
-}
-function isCacheCaptureEnvelope(value) {
-	if (typeof value !== "object" || value === null) return false;
-	if (!("type" in value) || value.type !== CACHE_CAPTURE_TYPE || !("encrypted" in value)) return false;
+async function decryptCacheCaptures(value) {
+	if (typeof value !== "object" || value === null || !("type" in value) || value.type !== CACHE_CAPTURE_TYPE || !("encrypted" in value)) return;
 	const encrypted = value.encrypted;
-	return typeof encrypted === "string" || typeof encrypted === "object" && encrypted !== null && isThenable(encrypted);
+	if (typeof encrypted !== "string" && !(typeof encrypted === "object" && encrypted !== null && "then" in encrypted && typeof encrypted.then === "function")) return;
+	const serialized = await decryptActionBoundArgs(Promise.resolve(encrypted));
+	if (typeof serialized !== "string") throw new Error("Invalid cache capture arguments");
+	const payload = JSON.parse(serialized);
+	if (payload.version !== 1) throw new Error("Invalid cache capture arguments");
+	const files = restoreFlightReply(payload.files);
+	if (typeof files === "string") throw new Error("Invalid cache capture files");
+	return await createFromReadableStream(new Response(Buffer.from(payload.result, "base64")).body, { temporaryReferences: new Map([...files].map(([id, file]) => [`$${id}`, file])) }, { preserveServerReferences: true });
 }
 function registerCachedFunction(fn, id, variant, options) {
 	return registerCachedFunction$1(fn, id, variant, {
 		...options,
 		decryptCaptures: decryptCacheCaptures,
-		encodeInvocationArgs: encryptCacheArguments
+		encodeInvocation: encryptArguments
 	});
 }
-/** Load and invoke one transformed cache function through its server-reference identity. */
+/** Replay the persisted payload without re-reading or re-encoding caller objects. */
 async function invokeCacheFunction(invocation, loadServerAction) {
 	const fn = await loadServerAction(invocation.referenceId);
 	if (!isUseCacheFunction(fn)) throw new Error(`Server reference ${invocation.referenceId} is not a cache function`);
-	await fn(...await decryptCacheArguments(invocation.encryptedArgs));
+	await replayCachedFunction(fn, await decryptArguments(invocation.encryptedArgs));
 }
 //#endregion
-export { decodeCacheArguments, encodeCacheArguments, encryptCacheCaptures, invokeCacheFunction, registerCachedFunction };
+export { encryptCacheCaptures, invokeCacheFunction, registerCachedFunction };

package/dist/shims/cache-flight-arguments.d.ts

@@ -0,0 +1,22 @@
+//#region src/shims/cache-flight-arguments.d.ts
+/** The persisted argument transport. React owns the object graph and wire protocol. */
+export type CacheFlightArguments = {
+  version: 1;
+  reply: string | ([string, string] | [string, string, string, number, string])[];
+  pagePropsIndex?: number;
+  layoutPropsIndex?: number;
+};
+/** Snapshot only the multipart transport, never traverse user arguments. */
+export declare function snapshotFlightReply(reply: string | FormData, pagePropsIndex?: number): Promise<CacheFlightArguments>;
+export declare function restoreFlightReply(args: CacheFlightArguments): string | FormData;
+/**
+ * Like Next.js (use-cache-wrapper.ts, `encodeFormData`), a binary entry is keyed
+ * by its bytes alone. Its name, type, and timestamp are replayed but not keyed:
+ * native FormData gives each Blob wrapper a wall-clock timestamp.
+ *
+ * Hashed synchronously, as Next.js derives its key without leaving the task: a
+ * cache hit must resolve before React flushes the shell, and an async digest
+ * waits for a later event-loop turn.
+ */
+export declare function flightArgumentsKey(args: CacheFlightArguments): string;
+//#endregion

package/dist/shims/cache-flight-arguments.js

@@ -0,0 +1,56 @@
+import { createHash } from "node:crypto";
+//#region src/shims/cache-flight-arguments.ts
+const blobType = Object.getOwnPropertyDescriptor(Blob.prototype, "type").get;
+const fileName = Object.getOwnPropertyDescriptor(File.prototype, "name").get;
+const fileTime = Object.getOwnPropertyDescriptor(File.prototype, "lastModified").get;
+/** Snapshot only the multipart transport, never traverse user arguments. */
+async function snapshotFlightReply(reply, pagePropsIndex) {
+	if (typeof reply === "string") return {
+		version: 1,
+		reply,
+		pagePropsIndex
+	};
+	const entries = [];
+	for (const [name, value] of reply) entries.push(typeof value === "string" ? [name, value] : [
+		name,
+		Buffer.from(await Blob.prototype.arrayBuffer.call(value)).toString("base64"),
+		fileName.call(value),
+		fileTime.call(value),
+		blobType.call(value)
+	]);
+	return {
+		version: 1,
+		reply: entries,
+		pagePropsIndex
+	};
+}
+function restoreFlightReply(args) {
+	if (typeof args.reply === "string") return args.reply;
+	const reply = new FormData();
+	for (const entry of args.reply) {
+		const [name, data] = entry;
+		reply.append(name, entry.length === 2 ? data : new File([Buffer.from(data, "base64")], entry[2], {
+			lastModified: entry[3],
+			type: entry[4]
+		}));
+	}
+	return reply;
+}
+/**
+* Like Next.js (use-cache-wrapper.ts, `encodeFormData`), a binary entry is keyed
+* by its bytes alone. Its name, type, and timestamp are replayed but not keyed:
+* native FormData gives each Blob wrapper a wall-clock timestamp.
+*
+* Hashed synchronously, as Next.js derives its key without leaving the task: a
+* cache hit must resolve before React flushes the shell, and an async digest
+* waits for a later event-loop turn.
+*/
+function flightArgumentsKey(args) {
+	const reply = typeof args.reply === "string" ? args.reply : args.reply.map((entry) => entry.length === 2 ? entry : [entry[0], { bytes: entry[1] }]);
+	return createHash("sha256").update(JSON.stringify({
+		...args,
+		reply
+	})).digest("base64url");
+}
+//#endregion
+export { flightArgumentsKey, restoreFlightReply, snapshotFlightReply };

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

@@ -15,8 +15,17 @@ export type UnstableCacheObservation = Readonly<{
   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;
+};
 export type CacheState = {
   actionRevalidationKind: ActionRevalidationKind;
+  cacheLifeSink: CacheLifeSink | null;
   pendingRevalidatedTags: Set<string>;
   pendingRevalidations: Set<Promise<void>>;
   requestScopedCacheLife: CacheLifeConfig | null;
@@ -70,6 +79,12 @@ export declare function _captureRequestScopedCacheLifeAccessors(): {
 };
 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
+ * done on the request's behalf after the fact leaves the request untouched.
+ */
+export declare function runWithDetachedCacheObservations<T>(fn: () => Promise<T>): Promise<T>;
 export declare function shouldServeStaleUnstableCacheEntry(): boolean;
 //#endregion
 export { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext };

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

@@ -47,6 +47,7 @@ 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,
 	pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 	pendingRevalidations: /* @__PURE__ */ new Set(),
 	requestScopedCacheLife: null,
@@ -60,12 +61,14 @@ 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,
 		pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 		pendingRevalidations: /* @__PURE__ */ new Set(),
 		requestScopedCacheLife: null,
@@ -146,15 +149,17 @@ async function _drainPendingRevalidations() {
 	}
 	if (didReject) throw firstRejection;
 }
+function mergeCacheLife(current, config) {
+	if (current === null) return { ...config };
+	if (config.stale !== void 0) current.stale = current.stale !== void 0 ? Math.min(current.stale, config.stale) : config.stale;
+	if (config.revalidate !== void 0) current.revalidate = current.revalidate !== void 0 ? Math.min(current.revalidate, config.revalidate) : config.revalidate;
+	if (config.expire !== void 0) current.expire = current.expire !== void 0 ? Math.min(current.expire, config.expire) : config.expire;
+	return current;
+}
 function _setRequestScopedCacheLife(config) {
 	const state = getCacheState();
-	if (state.requestScopedCacheLife === null) {
-		state.requestScopedCacheLife = { ...config };
-		return;
-	}
-	if (config.stale !== void 0) state.requestScopedCacheLife.stale = state.requestScopedCacheLife.stale !== void 0 ? Math.min(state.requestScopedCacheLife.stale, config.stale) : config.stale;
-	if (config.revalidate !== void 0) state.requestScopedCacheLife.revalidate = state.requestScopedCacheLife.revalidate !== void 0 ? Math.min(state.requestScopedCacheLife.revalidate, config.revalidate) : config.revalidate;
-	if (config.expire !== void 0) state.requestScopedCacheLife.expire = state.requestScopedCacheLife.expire !== void 0 ? Math.min(state.requestScopedCacheLife.expire, config.expire) : config.expire;
+	state.requestScopedCacheLife = mergeCacheLife(state.requestScopedCacheLife, config);
+	if (state.cacheLifeSink) state.cacheLifeSink.cacheLife = mergeCacheLife(state.cacheLifeSink.cacheLife, config);
 }
 function _peekRequestScopedCacheLife() {
 	const config = getCacheState().requestScopedCacheLife;
@@ -193,8 +198,26 @@ function recordUnstableCacheObservation(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
+* 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()
+	}, 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, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, shouldServeStaleUnstableCacheEntry };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry };

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

@@ -1,6 +1,7 @@
 import { CacheLifeConfig } from "./cache-request-state.js";
-import { markAppPagePropsForUseCache } from "./internal/app-page-props-cache-key.js";
+import { CacheFlightArguments } from "./cache-flight-arguments.js";
 //#region src/shims/cache-runtime.d.ts
+export declare function replayCachedFunction(fn: object, args: CacheFlightArguments): Promise<unknown>;
 /**
  * Used purely as `cause` for the nested-dynamic cache error: its captured stack
  * points at the inner "use cache" invocation that propagated a dynamic cache
@@ -52,15 +53,6 @@ export declare function getCacheContext(): CacheContext | null;
  * Exported for testing.
  */
 export declare function buildUseCacheKey(id: string, keySeed: string | undefined, argsKey?: string): string;
-/**
- * Convert an encodeReply result (string | FormData) to a cache key string.
- * For FormData (binary args), produces a deterministic SHA-256 hash over
- * the sorted entries. We can't hash `new Response(formData).arrayBuffer()`
- * because multipart boundaries are non-deterministic across serializations.
- *
- * Exported for testing.
- */
-export declare function replyToCacheKey(reply: string | FormData): Promise<string>;
 export type PrivateCacheState = {
   _privateCache: Map<string, unknown> | null;
 };
@@ -86,7 +78,7 @@ export type RegisterCachedFunctionOptions = {
   /** Number of declared arguments supplied by the directive transform. */
   argumentCount?: number;
   decryptCaptures?: (value: unknown) => Promise<unknown[] | undefined>;
-  encodeInvocationArgs?: (args: unknown[]) => Promise<string>;
+  encodeInvocation?: (args: CacheFlightArguments) => Promise<string>;
   serverReferenceId?: string;
 };
 /**
@@ -99,13 +91,8 @@ export type RegisterCachedFunctionOptions = {
  * @returns A wrapper function that checks cache before calling the original
  */
 export declare function registerCachedFunction<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, id: string, variant?: string, options?: RegisterCachedFunctionOptions): (...args: TArgs) => Promise<TResult>;
+/** Memoize in one React render without skipping cache guards or scoped serialization. */
+export declare function memoizeInCacheScope<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => TResult): (...args: TArgs) => TResult;
 /** Whether a loaded server reference is a transformed `"use cache"` function. */
 export declare function isUseCacheFunction(value: unknown): value is (...args: unknown[]) => Promise<unknown>;
-/**
- * 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.
- */
-export declare function isThenableObject(value: object): value is PromiseLike<unknown>;
-//#endregion
-export { markAppPagePropsForUseCache };
+//#endregion