vinext 1.0.0-beta.11 → 1.0.0-beta.13

package/dist/server/rsc-stream-hints.js

@@ -51,7 +51,7 @@ function concatBytes(first, second) {
 	combined.set(second, first.byteLength);
 	return combined;
 }
-function indexOfByte(bytes, byte, from = 0) {
+function indexOfByte(bytes, byte, from) {
 	for (let index = from; index < bytes.byteLength; index++) if (bytes[index] === byte) return index;
 	return -1;
 }
@@ -70,8 +70,35 @@ function parseHexBytes(bytes, start, end) {
 function isUntaggedJsonRowStart(byte) {
 	return byte === 34 || byte === 45 || byte >= 48 && byte <= 57 || byte === 91 || byte === 102 || byte === 110 || byte === 116 || byte === 123;
 }
+const COLON_BYTE = 58;
+const COMMA_BYTE = 44;
+const NEWLINE_BYTE = 10;
+const HINT_TAG_BYTE = 72;
+const LINK_HINT_CODE_BYTE = 76;
+function createAsciiTagTable(tags) {
+	const table = /* @__PURE__ */ new Uint8Array(128);
+	for (const tag of tags) table[tag.charCodeAt(0)] = 1;
+	return table;
+}
+const LENGTH_PREFIXED_ROW_TAG_TABLE = createAsciiTagTable(LENGTH_PREFIXED_ROW_TAGS);
+const NEWLINE_PREFIXED_ROW_TAG_TABLE = createAsciiTagTable(NEWLINE_PREFIXED_ROW_TAGS);
+function isTagInTable(table, byte) {
+	return byte < 128 && table[byte] === 1;
+}
+/**
+* Rewrite stylesheet preload hints in a React Flight stream.
+*
+* The rewrite is byte-length preserving, so this transform keeps React's
+* text chunk boundaries instead of re-emitting one chunk per Flight row. Every
+* downstream consumer (the tee, the SSR Flight client, the inline RSC embed,
+* RSC response wrappers) pays a per-chunk cost, and splitting per row
+* multiplied the chunk count roughly 8x on content-heavy pages. Chunks with
+* no stylesheet hint are forwarded as-is without copying; only rows whose
+* tag is `HL` are decoded and inspected. Length-prefixed bodies remain separate
+* so binary bytes do not force adjacent text through the embed's base64 path.
+*/
 function normalizeReactFlightPreloadHints(stream) {
-	let carry = /* @__PURE__ */ new Uint8Array();
+	let carry = null;
 	let rawBytesRemaining = 0;
 	let passThrough = false;
 	return stream.pipeThrough(new TransformStream({
@@ -80,56 +107,64 @@ function normalizeReactFlightPreloadHints(stream) {
 				controller.enqueue(chunk);
 				return;
 			}
-			let bytes = concatBytes(carry, chunk);
-			carry = /* @__PURE__ */ new Uint8Array();
-			while (bytes.byteLength > 0) {
+			const bytes = carry === null ? chunk : concatBytes(carry, chunk);
+			carry = null;
+			const byteLength = bytes.byteLength;
+			let offset = 0;
+			let emittedThrough = 0;
+			let output = bytes;
+			let ownsOutput = bytes !== chunk;
+			while (offset < byteLength) {
 				if (rawBytesRemaining > 0) {
-					const length = Math.min(rawBytesRemaining, bytes.byteLength);
-					controller.enqueue(bytes.slice(0, length));
+					const length = Math.min(rawBytesRemaining, byteLength - offset);
+					if (offset > emittedThrough) controller.enqueue(output.subarray(emittedThrough, offset));
+					controller.enqueue(bytes.subarray(offset, offset + length));
 					rawBytesRemaining -= length;
-					bytes = bytes.subarray(length);
+					offset += length;
+					emittedThrough = offset;
 					continue;
 				}
-				const colon = indexOfByte(bytes, 58);
-				if (colon === -1 || colon + 1 === bytes.byteLength) {
-					carry = bytes.slice();
-					return;
-				}
-				const tag = String.fromCharCode(bytes[colon + 1]);
-				if (LENGTH_PREFIXED_ROW_TAGS.has(tag)) {
-					const comma = indexOfByte(bytes, 44, colon + 2);
-					if (comma === -1) {
-						carry = bytes.slice();
-						return;
-					}
+				const colon = indexOfByte(bytes, COLON_BYTE, offset);
+				if (colon === -1 || colon + 1 === byteLength) break;
+				const tagByte = bytes[colon + 1];
+				if (isTagInTable(LENGTH_PREFIXED_ROW_TAG_TABLE, tagByte)) {
+					const comma = indexOfByte(bytes, COMMA_BYTE, colon + 2);
+					if (comma === -1) break;
 					const length = parseHexBytes(bytes, colon + 2, comma);
 					if (length != null) {
-						controller.enqueue(bytes.slice(0, comma + 1));
 						rawBytesRemaining = length;
-						bytes = bytes.subarray(comma + 1);
+						offset = comma + 1;
 						continue;
 					}
 					passThrough = true;
-					controller.enqueue(bytes);
-					return;
+					offset = byteLength;
+					break;
 				}
-				const tagByte = bytes[colon + 1];
-				if (!NEWLINE_PREFIXED_ROW_TAGS.has(tag) && !isUntaggedJsonRowStart(tagByte)) {
+				if (!isTagInTable(NEWLINE_PREFIXED_ROW_TAG_TABLE, tagByte) && !isUntaggedJsonRowStart(tagByte)) {
 					passThrough = true;
-					controller.enqueue(bytes);
-					return;
+					offset = byteLength;
+					break;
 				}
-				const newline = indexOfByte(bytes, 10);
-				if (newline === -1) {
-					carry = bytes.slice();
-					return;
+				const newline = indexOfByte(bytes, NEWLINE_BYTE, offset);
+				if (newline === -1) break;
+				if (tagByte === HINT_TAG_BYTE && bytes[colon + 2] === LINK_HINT_CODE_BYTE) {
+					const line = bytes.subarray(offset, newline + 1);
+					const normalized = normalizeReactFlightHintLine(line);
+					if (normalized !== line) {
+						if (!ownsOutput) {
+							output = bytes.slice();
+							ownsOutput = true;
+						}
+						output.set(normalized, offset);
+					}
 				}
-				controller.enqueue(normalizeReactFlightHintLine(bytes.slice(0, newline + 1)));
-				bytes = bytes.subarray(newline + 1);
+				offset = newline + 1;
 			}
+			if (offset < byteLength) carry = bytes.slice(offset);
+			if (offset > emittedThrough) controller.enqueue(offset === byteLength && emittedThrough === 0 ? output : output.subarray(emittedThrough, offset));
 		},
 		flush(controller) {
-			if (carry.byteLength > 0) controller.enqueue(rawBytesRemaining > 0 ? carry : normalizeReactFlightHintLine(carry));
+			if (carry !== null && carry.byteLength > 0) controller.enqueue(rawBytesRemaining > 0 ? carry : normalizeReactFlightHintLine(carry));
 		}
 	}));
 }

package/dist/server/seed-cache.js

@@ -1,5 +1,5 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { appIsrCacheKey, isrCacheKey, isrSet, isrSetPrerenderedAppPage } from "./isr-cache.js";
+import { appIsrCacheKey, isrSet, isrSetPrerenderedAppPage } from "./isr-cache.js";
 import { addPregeneratedConcretePath, addPregeneratedRoute, clearPregeneratedConcretePaths, normalizePregeneratedPathname } from "./pregenerated-concrete-paths.js";
 import { getRenderedAppRoutes, getRenderedMetadataRoutes, isFallbackShellArtifactPath, readPrerenderManifest } from "./prerender-manifest.js";
 import { buildAppPageCacheTags, buildAppRouteCacheTags } from "./app-page-cache.js";
@@ -64,9 +64,8 @@ async function seedMemoryCacheFromPrerender(serverDir, options) {
 		if (!isFallbackShellArtifactPath(concretePathname, route)) addPregeneratedConcretePath(route.route, concretePathname);
 		const artifactPathname = route.path ?? route.route;
 		const cachePathname = normalizePregeneratedPathname(artifactPathname);
-		const baseKey = isrCacheKey("app", cachePathname, buildId);
-		const htmlKey = options?.buildAppPageHtmlKey?.(cachePathname) ?? baseKey + ":html";
-		const rscKey = options?.buildAppPageRscKey?.(cachePathname) ?? baseKey + ":rsc";
+		const htmlKey = options?.buildAppPageHtmlKey?.(cachePathname) ?? appIsrCacheKey(cachePathname, "html", buildId);
+		const rscKey = options?.buildAppPageRscKey?.(cachePathname) ?? appIsrCacheKey(cachePathname, "rsc", buildId);
 		const revalidateSeconds = typeof route.revalidate === "number" ? route.revalidate : void 0;
 		const expireSeconds = typeof route.expire === "number" ? route.expire : void 0;
 		const staleSeconds = typeof route.stale === "number" && route.stale >= 0 ? route.stale : void 0;

package/dist/server/socket-error-backstop.js

@@ -33,7 +33,7 @@
 *
 * **Prerender check is dynamic, not install-time.** Prerender (in
 * `build/prerender.ts` and `build/run-prerender.ts`) calls
-* `startProdServer()` from inside `vinext build` to render pages
+* `startProdServer()` from inside `vite build` to render pages
 * against a real HTTP server. User `fetch()` calls during prerender
 * hit external APIs that can drop connections; absorbing those would
 * silently produce corrupt prerendered output instead of crashing

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

@@ -6,7 +6,45 @@ type CacheCaptureEnvelope = {
   type: typeof CACHE_CAPTURE_TYPE;
   encrypted: string | PromiseLike<string>;
 };
+/**
+ * Flight serializes a promise as its resolved value and drops its own fields.
+ * Next.js params are promises that also expose their resolved fields, and the
+ * cache key is built from those fields, so the payload carries each such
+ * promise's fields next to the arguments and decoding assigns them back.
+ */
+type EncodedCacheArguments = {
+  args: unknown[];
+  thenableObjects: EncodedThenableObject[];
+};
+/**
+ * Flight writes each object once, so `promise` decodes to the same promise as
+ * every other reference to it, including ones inside resolved values, and the
+ * fields share references with the arguments. The fields build the cache key;
+ * the resolved value can differ: the params proxy hides params named like
+ * promise or React fields (`value`, `status`) from its own keys but still
+ * resolves to them.
+ */
+type EncodedThenableObject = {
+  fields: Record<string, unknown>;
+  promise: PromiseLike<unknown>;
+};
 export declare function encryptCacheCaptures(captures: unknown[]): CacheCaptureEnvelope;
+/**
+ * What to do when a read would run a getter: `reject` throws
+ * `UnreplayableCacheArgumentsError`, `skip` leaves the getter unread.
+ */
+type GetterHandling = "reject" | "skip";
+/**
+ * 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.
+ */
+export declare function encodeCacheArguments(args: unknown[], getters?: GetterHandling): Promise<EncodedCacheArguments>;
+/** Restore the promise fields that `encodeCacheArguments` captured before Flight encoding. */
+export declare function decodeCacheArguments(value: unknown): unknown[];
 export declare function registerCachedFunction<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, id: string, variant: string, options: RegisterCachedFunctionOptions): (...args: TArgs) => Promise<TResult>;
 /** Load and invoke one transformed cache function through its server-reference identity. */
 export declare function invokeCacheFunction(invocation: VinextCacheFunctionInvocation, loadServerAction: (id: string) => Promise<unknown>): Promise<void>;

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

@@ -1,39 +1,190 @@
-import { isUseCacheFunction, registerCachedFunction as registerCachedFunction$1 } from "./cache-runtime.js";
+import { isThenableObject, isUseCacheFunction, registerCachedFunction as registerCachedFunction$1 } from "./cache-runtime.js";
 import { decryptActionBoundArgs, encryptActionBoundArgs } from "@vitejs/plugin-rsc/utils/encryption-runtime";
 //#region src/shims/cache-callable-runtime.ts
 const CACHE_CAPTURE_TYPE = "use-cache-captures";
 function encryptCacheCaptures(captures) {
 	return {
 		type: CACHE_CAPTURE_TYPE,
-		encrypted: encryptActionBoundArgs(captures)
+		encrypted: encryptCaptures(captures)
 	};
 }
 async function decryptCacheCaptures(value) {
 	if (!isCacheCaptureEnvelope(value)) return;
-	const captures = await decryptActionBoundArgs(Promise.resolve(value.encrypted));
-	if (!Array.isArray(captures)) throw new Error("Invalid cache capture payload");
-	return captures;
+	return decryptCacheArguments(value.encrypted);
+}
+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
+				});
+			}
+			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);
+		}
+		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;
+}
+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;
 	const encrypted = value.encrypted;
-	return typeof encrypted === "string" || typeof encrypted === "object" && encrypted !== null && "then" in encrypted && typeof encrypted.then === "function";
+	return typeof encrypted === "string" || typeof encrypted === "object" && encrypted !== null && isThenable(encrypted);
 }
 function registerCachedFunction(fn, id, variant, options) {
 	return registerCachedFunction$1(fn, id, variant, {
 		...options,
 		decryptCaptures: decryptCacheCaptures,
-		encodeInvocationArgs: encryptActionBoundArgs
+		encodeInvocationArgs: encryptCacheArguments
 	});
 }
 /** Load and invoke one transformed cache function through its server-reference identity. */
 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`);
-	const args = await decryptActionBoundArgs(Promise.resolve(invocation.encryptedArgs));
-	if (!Array.isArray(args)) throw new Error("Invalid cache function arguments");
-	await fn(...args);
+	await fn(...await decryptCacheArguments(invocation.encryptedArgs));
 }
 //#endregion
-export { encryptCacheCaptures, invokeCacheFunction, registerCachedFunction };
+export { decodeCacheArguments, encodeCacheArguments, encryptCacheCaptures, invokeCacheFunction, registerCachedFunction };

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

@@ -83,14 +83,6 @@ export type RegisterCachedFunctionOptions = {
    * transform records this separately for metadata parent resolution.
    */
   acceptsSecondArgument?: boolean;
-  /**
-   * Internal transform metadata for file-level `"use cache"` default exports
-   * in App Router `page.*` files. Page components receive framework-owned
-   * `{ params, searchParams }` props. React may copy that props object before
-   * invocation, so this invariant must live at the cached function boundary
-   * rather than on the intermediate createElement config object.
-   */
-  appPageDefaultExport?: boolean;
   /** Number of declared arguments supplied by the directive transform. */
   argumentCount?: number;
   decryptCaptures?: (value: unknown) => Promise<unknown[] | undefined>;
@@ -109,5 +101,11 @@ export type RegisterCachedFunctionOptions = {
 export declare function registerCachedFunction<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, id: string, variant?: string, options?: RegisterCachedFunctionOptions): (...args: TArgs) => Promise<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 };

package/dist/shims/cache-runtime.js

@@ -6,10 +6,11 @@ import { isRouteCacheabilityProbe, recordRouteCacheabilityProbeBailout } from ".
 import { getDataCacheHandler } from "./cache-handler.js";
 import { suppressHangingPromiseAbortRejections } from "./internal/make-hanging-promise.js";
 import { createPprFallbackShellSuspensePromise, trackPprFallbackShellCacheTask } from "./ppr-fallback-shell.js";
-import { isDraftModeEnabled, markDynamicUsage } from "./headers.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
 /**
@@ -309,7 +310,8 @@ 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) => {
 		if (cacheVariant === "private") {
@@ -346,16 +348,27 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 			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 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 callArgs = executionArgs;
+			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, { omitAppPageSearchParamsFromFirstArg }) : [];
+				const processedArgs = executionArgs.length > 0 ? unwrapThenableObjectArray(executionArgs, {
+					pagePropsIndex,
+					omitMarkedAppPageSearchParams: omitAppPageSearchParams
+				}) : [];
 				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);
+					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;
 			}
@@ -418,7 +431,7 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 				let cacheFunctionInvocation;
 				if (options.serverReferenceId && options.encodeInvocationArgs) try {
 					cacheFunctionInvocation = {
-						encryptedArgs: await options.encodeInvocationArgs(admittedArgs),
+						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
@@ -482,7 +495,7 @@ const USE_CACHE_FUNCTION_SYMBOL = Symbol.for("vinext.useCacheFunction");
 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 typeof value === "function" && Reflect.get(value, USE_CACHE_FUNCTION_SYMBOL) === true;
+	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\".");
@@ -590,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";
@@ -637,4 +702,4 @@ function stableStringify(value, seen) {
 	return JSON.stringify(value);
 }
 //#endregion
-export { NestedDynamicUseCacheError, buildUseCacheKey, cacheContextStorage, clearPrivateCache, getCacheContext, isUseCacheFunction, markAppPagePropsForUseCache, registerCachedFunction, replyToCacheKey, runWithPrivateCache };
+export { NestedDynamicUseCacheError, buildUseCacheKey, cacheContextStorage, clearPrivateCache, getCacheContext, isThenableObject, isUseCacheFunction, markAppPagePropsForUseCache, registerCachedFunction, replyToCacheKey, runWithPrivateCache };

package/dist/shims/constants.js

@@ -91,7 +91,7 @@ const CONFIG_FILES = [
 	"next.config.js",
 	"next.config.mjs",
 	"next.config.ts",
-	...process?.features?.typescript ? ["next.config.mts"] : []
+	...typeof process !== "undefined" && process.features?.typescript ? ["next.config.mts"] : []
 ];
 const BUILD_ID_FILE = "BUILD_ID";
 const BLOCKED_PAGES = [