vinext 1.0.0-beta.12 → 1.0.0-beta.13

package/dist/server/prod-server.js

@@ -1,23 +1,23 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { isUnknownRecord } from "../utils/record.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
+import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix } from "../utils/asset-prefix.js";
+import { StaticFileCache, contentTypeForPath, etagFromFilenameHash } from "./static-file-cache.js";
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
-import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
 import { VINEXT_PRERENDER_RENDER_ERROR_HEADER } from "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { notFoundResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { readStaticFileSignal } from "./static-file-signal.js";
 import { canonicalizeRequestPathname, filterInternalHeaders } from "./request-pipeline.js";
-import { isUnknownRecord } from "../utils/record.js";
 import { parseHttpDate } from "./http-date.js";
 import { evaluateStaticPreconditions } from "./http-conditional.js";
 import { buildNextDataNotFoundResponse, encodeUrlParserIgnoredCharacters, isNextDataPathname, normalizeNextDataPagePathname, parseNextDataPathname, shouldAddTrailingSlashToPagesDataPath, urlParserCreatesPagesDataPath } from "./pages-data-route.js";
-import { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix } from "../utils/asset-prefix.js";
 import { setPagesClientAssets } from "./pages-client-assets.js";
 import { resolveRequestHost, resolveRequestProtocol, trustProxy, trustedHosts } from "./proxy-trust.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath, isSafeImageContentType, parseImageParams } from "./image-optimization.js";
 import { installSocketErrorBackstop } from "./socket-error-backstop.js";
-import { StaticFileCache, contentTypeForPath, etagFromFilenameHash } from "./static-file-cache.js";
 import { collectInlineCssManifest } from "../build/inline-css.js";
 import { readTrustedRevalidationHostname } from "./revalidation-host.js";
 import { traceFrameworkRequest } from "./request-tracing.js";
@@ -32,8 +32,8 @@ import { ifRangeAllowsRange, parseByteRange } from "./http-range.js";
 import { createRequire } from "node:module";
 import { AsyncLocalStorage } from "node:async_hooks";
 import fs from "node:fs";
-import fsp from "node:fs/promises";
 import { pathToFileURL } from "node:url";
+import fsp from "node:fs/promises";
 import { Readable, pipeline } from "node:stream";
 import zlib from "node:zlib";
 import { createServer } from "node:http";
@@ -41,7 +41,7 @@ import { createServer } from "node:http";
 /**
 * Production server for vinext.
 *
-* Serves the built output from `vinext build`. Handles:
+* Serves the built output from `vite build`. Handles:
 * - Static asset serving from client build output
 * - Pages Router: SSR rendering + API route handling
 * - App Router: RSC/SSR rendering, route handlers, server actions
@@ -842,7 +842,7 @@ async function startProdServer(options = {}) {
 	const isAppRouter = fs.existsSync(rscEntryPath);
 	if (!isAppRouter && !fs.existsSync(serverEntryPath)) {
 		console.error(`[vinext] No build output found in ${outDir}`);
-		console.error("Run `vinext build` first.");
+		console.error("Run `vite build` first.");
 		process.exit(1);
 	}
 	if (isAppRouter) return startAppRouterServer({

package/dist/server/request-pipeline.js

@@ -1,7 +1,7 @@
-import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
 import "../utils/protocol-headers.js";
-import { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS } from "./headers.js";
 import { getUnconsumedMiddlewareRequestHeaders } from "../utils/middleware-request-headers.js";
+import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
+import { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS } from "./headers.js";
 import { forbiddenResponse, methodNotAllowedResponse, notFoundResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { createStaticFileSignal } from "./static-file-signal.js";

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,7 @@ 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) => {
@@ -347,12 +348,19 @@ 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();
 					const encoded = await rsc.encodeReply(processedArgs, { temporaryReferences: tempRefs });
@@ -423,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
@@ -487,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\".");
@@ -595,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";
@@ -642,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/font-local.js

@@ -1,5 +1,5 @@
-import { fnv1a64 } from "../utils/hash.js";
 import { escapeCSSString, formatFontClassRule, getFontMimeType, resolveSingleFaceStyle, sanitizeCSSVarName, sanitizeFallback, sanitizeFontDescriptorValue } from "./font-utils.js";
+import { fnv1a64 } from "../utils/hash.js";
 //#region src/shims/font-local.ts
 /**
 * next/font/local shim

package/dist/shims/form.js

@@ -1,4 +1,5 @@
 "use client";
+import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { VINEXT_MOUNTED_SLOTS_HEADER } from "../server/app-rsc-vary.js";
 import "../server/headers.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
@@ -6,7 +7,6 @@ import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "../server/app-rsc-re
 import { AppElementsWire } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
 import { withBasePath } from "./url-utils.js";
-import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { createRscRequestHeaders, createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
 import { hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { getMountedSlotsHeader, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, navigateClientSide, prefetchRscResponse } from "./navigation.js";

package/dist/shims/headers.js

@@ -1,9 +1,9 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
-import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
 import { MIDDLEWARE_SET_COOKIE_HEADER } from "../utils/protocol-headers.js";
-import { FLIGHT_HEADERS, NEXT_HTML_REQUEST_ID_HEADER, NEXT_REQUEST_ID_HEADER } from "../server/headers.js";
 import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
+import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
+import { FLIGHT_HEADERS, NEXT_HTML_REQUEST_ID_HEADER, NEXT_REQUEST_ID_HEADER } from "../server/headers.js";
 import { serializeSetCookie, validateCookieName } from "./internal/cookie-serialize.js";
 import { createPprFallbackShellSuspensePromise } from "./ppr-fallback-shell.js";
 //#region src/shims/headers.ts

package/dist/shims/internal/app-page-props-cache-key.d.ts

@@ -1,4 +1,33 @@
 //#region src/shims/internal/app-page-props-cache-key.d.ts
+/**
+ * Enumerable page marker, matching Next.js's `$$isPage` prop. It must be an
+ * ordinary string key: React's createElement drops symbol and non-enumerable
+ * props before a server component is invoked.
+ */
+export declare const APP_PAGE_USE_CACHE_MARKER = "$$isPage";
 export declare function markAppPagePropsForUseCache<T extends object>(props: T): T;
 export declare function isMarkedAppPagePropsObject(value: object): boolean;
+/**
+ * Whether `fn` is a transformed `"use cache"` function, including a bound
+ * one. Like Next.js's `isUseCacheFunction`, this survives `.bind()`: React's
+ * server-reference `bind` copies `$$typeof`/`$$id` to the bound function but
+ * not vinext's own marker symbol.
+ */
+export declare function isUseCacheFunctionReference(fn: unknown): boolean;
+/**
+ * Add Next.js's `$$isPage` marker when `fn` is a `"use cache"` function
+ * invoked as a page component or as a page's generateMetadata/generateViewport
+ * (create-component-tree.tsx, resolve-metadata.ts `createSegmentProps`). The
+ * cache wrapper reads and removes it, so page semantics follow the invocation
+ * even when the cached function is defined in (or re-exported from) another
+ * module, or bound.
+ */
+export declare function withUseCachePageMarker<T extends Record<string, unknown>>(fn: unknown, props: T): T;
+/**
+ * Whether `value` is page props carrying the `$$isPage` marker. Only plain
+ * objects qualify: the framework always passes a plain props object, and
+ * reading the marker through a thenable params/searchParams proxy would be
+ * observed as a param access.
+ */
+export declare function hasUseCachePageMarker(value: unknown): value is Record<string, unknown>;
 //#endregion

package/dist/shims/internal/app-page-props-cache-key.js

@@ -1,5 +1,20 @@
 //#region src/shims/internal/app-page-props-cache-key.ts
 const APP_PAGE_PROPS_CACHE_KEY_MARKER = Symbol.for("vinext.appPagePropsCacheKeyMarker");
+const USE_CACHE_FUNCTION_SYMBOL = Symbol.for("vinext.useCacheFunction");
+const SERVER_REFERENCE_TAG = Symbol.for("react.server.reference");
+/**
+* Server reference ids of transformed cache functions end in the export name
+* the use-cache transform assigns (`secureExportName` in
+* plugins/use-cache-callable.ts): `$$vinext_cache_` plus an HMAC-SHA256 hex
+* digest. `"use server"` actions keep their own export names.
+*/
+const USE_CACHE_SERVER_REFERENCE_ID_RE = /#\$\$vinext_cache_[0-9a-f]{64}$/;
+/**
+* Enumerable page marker, matching Next.js's `$$isPage` prop. It must be an
+* ordinary string key: React's createElement drops symbol and non-enumerable
+* props before a server component is invoked.
+*/
+const APP_PAGE_USE_CACHE_MARKER = "$$isPage";
 function markAppPagePropsForUseCache(props) {
 	Object.defineProperty(props, APP_PAGE_PROPS_CACHE_KEY_MARKER, {
 		configurable: false,
@@ -12,5 +27,42 @@ function markAppPagePropsForUseCache(props) {
 function isMarkedAppPagePropsObject(value) {
 	return Reflect.get(value, APP_PAGE_PROPS_CACHE_KEY_MARKER) === true;
 }
+/**
+* Whether `fn` is a transformed `"use cache"` function, including a bound
+* one. Like Next.js's `isUseCacheFunction`, this survives `.bind()`: React's
+* server-reference `bind` copies `$$typeof`/`$$id` to the bound function but
+* not vinext's own marker symbol.
+*/
+function isUseCacheFunctionReference(fn) {
+	if (typeof fn !== "function") return false;
+	if (Reflect.get(fn, USE_CACHE_FUNCTION_SYMBOL) === true) return true;
+	const reference = fn;
+	return reference.$$typeof === SERVER_REFERENCE_TAG && typeof reference.$$id === "string" && USE_CACHE_SERVER_REFERENCE_ID_RE.test(reference.$$id);
+}
+/**
+* Add Next.js's `$$isPage` marker when `fn` is a `"use cache"` function
+* invoked as a page component or as a page's generateMetadata/generateViewport
+* (create-component-tree.tsx, resolve-metadata.ts `createSegmentProps`). The
+* cache wrapper reads and removes it, so page semantics follow the invocation
+* even when the cached function is defined in (or re-exported from) another
+* module, or bound.
+*/
+function withUseCachePageMarker(fn, props) {
+	return isUseCacheFunctionReference(fn) ? {
+		...props,
+		[APP_PAGE_USE_CACHE_MARKER]: true
+	} : props;
+}
+/**
+* Whether `value` is page props carrying the `$$isPage` marker. Only plain
+* objects qualify: the framework always passes a plain props object, and
+* reading the marker through a thenable params/searchParams proxy would be
+* observed as a param access.
+*/
+function hasUseCachePageMarker(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return (prototype === Object.prototype || prototype === null) && value["$$isPage"] === true;
+}
 //#endregion
-export { isMarkedAppPagePropsObject, markAppPagePropsForUseCache };
+export { APP_PAGE_USE_CACHE_MARKER, hasUseCachePageMarker, isMarkedAppPagePropsObject, isUseCacheFunctionReference, markAppPagePropsForUseCache, withUseCachePageMarker };