vinext 1.2.1 → 1.3.1

package/dist/server/seed-cache.js

@@ -2,8 +2,8 @@ import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { appIsrCacheKey, appIsrFallbackShellKey, 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";
 import { getAppRouteOutputPath, getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
+import { buildAppPageCacheTags, buildAppRouteCacheTags } from "./app-page-cache.js";
 import fs from "node:fs";
 //#region src/server/seed-cache.ts
 /**

package/dist/server/server-reference-loader.js

@@ -1,4 +1,6 @@
 import { runOutsideRequestScopes } from "../shims/internal/als-registry.js";
+import { getRequestExecutionContext } from "../shims/request-context.js";
+import { shareIsolatePromise } from "./isolate-shared-promise.js";
 //#region src/server/server-reference-loader.ts
 /**
 * Keep server-reference module evaluation out of the request that first
@@ -21,7 +23,14 @@ const ISOLATED = Symbol.for("vinext.serverReferenceRequire.isolated");
 function isolateServerReferenceLoads() {
 	const load = globalThis.__vite_rsc_server_require__;
 	if (typeof load !== "function" || ISOLATED in load) return;
-	const isolated = (id) => runOutsideRequestScopes(() => load(id));
+	const started = /* @__PURE__ */ new WeakSet();
+	const isolated = (id) => {
+		const ctx = getRequestExecutionContext();
+		const loaded = runOutsideRequestScopes(() => load(id));
+		if (!(loaded instanceof Promise) || started.has(loaded)) return loaded;
+		started.add(loaded);
+		return shareIsolatePromise(loaded, ctx);
+	};
 	Object.defineProperty(isolated, ISOLATED, { value: true });
 	globalThis.__vite_rsc_server_require__ = isolated;
 }

package/dist/server/static-file-cache.d.ts

@@ -66,4 +66,5 @@ export declare class StaticFileCache {
  * so the caller can fall back to mtime-based ETags.
  */
 export declare function etagFromFilenameHash(relativePath: string, ext: string): string | null;
-//#endregion
+//#endregion
+export {};

package/dist/server/static-file-cache.js

@@ -37,6 +37,7 @@ const CONTENT_TYPES = {
 	".mp4": "video/mp4",
 	".ogg": "audio/ogg",
 	".ogv": "video/ogg",
+	".otf": "font/otf",
 	".pdf": "application/pdf",
 	".png": "image/png",
 	".rsc": "text/x-component",
@@ -178,6 +179,15 @@ var StaticFileCache = class StaticFileCache {
 		return this.entries.get(pathname);
 	}
 };
+const MANAGED_CHUNKS_SEGMENT = `${ASSET_PREFIX_URL_DIR}/chunks/`;
+const MANAGED_CSS_SEGMENT = `${ASSET_PREFIX_URL_DIR}/css/`;
+const MANAGED_WORKERS_SEGMENT = `${ASSET_PREFIX_URL_DIR}/workers/`;
+const MANAGED_MEDIA_SEGMENT = `${ASSET_PREFIX_URL_DIR}/media/`;
+const HASH_ONLY_BASENAME_RE = /^[A-Za-z0-9_-]{8}$/;
+const WORKER_BASENAME_RE = /^[0-9a-f]{8}-[A-Za-z0-9_-]{8}$/;
+function isInManagedDir(normalizedPath, segment) {
+	return normalizedPath.startsWith(segment) || normalizedPath.includes(`/${segment}`);
+}
 /**
 * Extract a stable weak ETag from a Vite hashed filename (e.g. `app-DqZc3R4n.js`).
 * The hash is a content hash computed by the bundler — deterministic across
@@ -190,14 +200,17 @@ var StaticFileCache = class StaticFileCache {
 */
 function etagFromFilenameHash(relativePath, ext) {
 	const basename = path.basename(relativePath, ext);
+	if (basename.length === 8 && HASH_ONLY_BASENAME_RE.test(basename)) {
+		const normalizedPath = toSlash(relativePath);
+		if (isInManagedDir(normalizedPath, MANAGED_CHUNKS_SEGMENT) || isInManagedDir(normalizedPath, MANAGED_CSS_SEGMENT)) return `W/"${basename}"`;
+	}
+	if (basename.length === 17 && WORKER_BASENAME_RE.test(basename) && isInManagedDir(toSlash(relativePath), MANAGED_WORKERS_SEGMENT)) return `W/"${basename}"`;
 	const lastDash = basename.lastIndexOf("-");
 	if (lastDash !== -1 && lastDash !== basename.length - 1) {
 		const suffix = basename.slice(lastDash + 1);
 		if (suffix.length >= 6 && suffix.length <= 12 && /^[A-Za-z0-9_-]+$/.test(suffix)) return `W/"${suffix}"`;
 	}
-	const normalizedPath = toSlash(relativePath);
-	const managedMediaSegment = `${ASSET_PREFIX_URL_DIR}/media/`;
-	if (normalizedPath.startsWith(managedMediaSegment) || normalizedPath.includes(`/${managedMediaSegment}`)) {
+	if (isInManagedDir(toSlash(relativePath), MANAGED_MEDIA_SEGMENT)) {
 		const lastDot = basename.lastIndexOf(".");
 		if (lastDot !== -1) {
 			const suffix = basename.slice(lastDot + 1);

package/dist/server/static-layout-client-reuse-proof.d.ts

@@ -10,4 +10,5 @@ type StaticLayoutClientReuseProofInput = Readonly<{
 export declare function createStaticLayoutClientReuseRouteId(layoutId: string): string;
 export declare function createStaticLayoutClientReusePayloadHash(input: StaticLayoutClientReuseProofInput): string;
 export declare function createStaticLayoutClientReuseArtifactCompatibility(input: StaticLayoutClientReuseProofInput): ArtifactCompatibilityEnvelope;
-//#endregion
+//#endregion
+export {};

package/dist/server/worker-revalidation-context.d.ts

@@ -9,4 +9,5 @@ type PlatformExecutionContext = Partial<ExecutionContextLike> & VinextRequestSta
  * on the normal header-scrubbing path.
  */
 export declare function createWorkerRevalidationContext(base: PlatformExecutionContext | undefined, handleInternalRequest: (request: Request, ctx: ExecutionContextLike) => Promise<Response>, defaultHostRuntime?: "node" | "worker"): ExecutionContextLike;
-//#endregion
+//#endregion
+export {};

package/dist/server/worker-stages.d.ts

@@ -40,4 +40,5 @@ export type WorkerResponseStageProps = PagesApiResponseStageProps | PagesPageRes
  */
 export type DispatchWorkerResponseStage = VinextResponseStageTransport<WorkerResponseStageProps>;
 export declare function isPagesResponseStageProps(value: unknown): value is WorkerResponseStageProps;
-//#endregion
+//#endregion
+export {};

package/dist/server/worker-utils.js

@@ -108,7 +108,7 @@ async function resolveStaticAssetSignal(signalResponse, options) {
 * overrides, so a removed `Range` or replaced validator reaches the asset fetch.
 */
 function createStaticAssetRequest(assetPath, sourceRequest, headers = null) {
-	const assetUrl = new URL(assetPath, sourceRequest.url);
+	const assetUrl = new URL(assetPath.replace(/[?#]/g, (character) => encodeURIComponent(character)), sourceRequest.url);
 	if (sourceRequest.method === "GET" || sourceRequest.method === "HEAD") return headers ? new Request(new Request(assetUrl, sourceRequest), { headers }) : new Request(assetUrl, sourceRequest);
 	return new Request(assetUrl, {
 		method: sourceRequest.method,

package/dist/shims/app.d.ts

@@ -34,4 +34,5 @@ export default class App<P = any, CP = any, S = any> extends React.Component<P &
   static getInitialProps: typeof appGetInitialProps;
   render(): React.ReactElement;
 }
-//#endregion
+//#endregion
+export {};

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

@@ -12,4 +12,5 @@ export declare function registerCachedFunction<TArgs extends unknown[], TResult>
 }): (...args: TArgs) => Promise<TResult>;
 /** Replay the persisted payload without re-reading or re-encoding caller objects. */
 export declare function invokeCacheFunction(invocation: VinextCacheFunctionInvocation, loadServerAction: (id: string) => Promise<unknown>): Promise<void>;
-//#endregion
+//#endregion
+export {};

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

@@ -96,7 +96,7 @@ type MemoryCacheHandlerOptions = Pick<CacheHandlerContext, "maxMemoryCacheSize">
 };
 export declare class MemoryCacheHandler implements CacheHandler {
   private store;
-  private tagRevalidatedAt;
+  private tagsManifest;
   private readonly maxMemoryCacheSize;
   private currentMemoryCacheSize;
   constructor(options?: number | MemoryCacheHandlerOptions);
@@ -106,7 +106,11 @@ export declare class MemoryCacheHandler implements CacheHandler {
   private evictLeastRecentlyUsed;
   get(key: string, ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
   set(key: string, data: IncrementalCacheValue | null, ctx?: Record<string, unknown>): Promise<void>;
-  revalidateTag(tags: string | string[]): Promise<void>;
+  revalidateTag(tags: string | string[], durations?: {
+    expire?: number;
+  }): Promise<void>;
+  private isTagExpired;
+  private isTagStale;
   resetRequestCache(): void;
 }
 export declare function configureMemoryCacheHandler(options?: MemoryCacheHandlerOptions): void;
@@ -121,4 +125,5 @@ export declare function registerLazyDataCacheHandler(load: () => Promise<void>):
 export declare function getDataCacheHandler(): CacheHandler;
 export declare function setCacheHandler(handler: CacheHandler): void;
 export declare function getCacheHandler(): CacheHandler;
-//#endregion
+//#endregion
+export {};

package/dist/shims/cache-handler.js

@@ -1,3 +1,4 @@
+import { shareIsolatePromise } from "../server/isolate-shared-promise.js";
 import { readCacheControlNumberField, readCacheControlRevalidateField } from "../utils/cache-control-metadata.js";
 //#region src/shims/cache-handler.ts
 var NoOpCacheHandler = class {
@@ -47,7 +48,7 @@ function readPositiveNumberField(ctx, field) {
 }
 var MemoryCacheHandler = class {
 	store = /* @__PURE__ */ new Map();
-	tagRevalidatedAt = /* @__PURE__ */ new Map();
+	tagsManifest = /* @__PURE__ */ new Map();
 	maxMemoryCacheSize;
 	currentMemoryCacheSize = 0;
 	constructor(options) {
@@ -76,19 +77,20 @@ var MemoryCacheHandler = class {
 	async get(key, ctx) {
 		const entry = this.store.get(key);
 		if (!entry) return null;
+		const now = Date.now();
+		let hasStaleTag = false;
 		for (const tag of entry.tags) {
-			const revalidatedAt = this.tagRevalidatedAt.get(tag);
-			if (revalidatedAt && revalidatedAt >= entry.lastModified) {
+			if (this.isTagExpired(tag, entry.lastModified, now)) {
 				this.deleteEntry(key);
 				return null;
 			}
+			hasStaleTag ||= this.isTagStale(tag, entry.lastModified);
 		}
 		for (const tag of readStringArrayField(ctx, "softTags")) {
-			const revalidatedAt = this.tagRevalidatedAt.get(tag);
-			if (revalidatedAt && revalidatedAt >= entry.lastModified) return null;
+			if (this.isTagExpired(tag, entry.lastModified, now)) return null;
+			hasStaleTag ||= this.isTagStale(tag, entry.lastModified);
 		}
 		this.touchEntry(key, entry);
-		const now = Date.now();
 		if (entry.expireAt !== null && now > entry.expireAt) return {
 			lastModified: entry.lastModified,
 			value: entry.value,
@@ -97,7 +99,7 @@ var MemoryCacheHandler = class {
 		};
 		const requestedRevalidate = readPositiveNumberField(ctx, "revalidate");
 		const requestedRevalidateAt = requestedRevalidate === void 0 ? null : entry.lastModified + requestedRevalidate * 1e3;
-		if (entry.revalidateAt !== null && now > entry.revalidateAt || requestedRevalidateAt !== null && now > requestedRevalidateAt) return {
+		if (hasStaleTag || entry.revalidateAt !== null && now > entry.revalidateAt || requestedRevalidateAt !== null && now > requestedRevalidateAt) return {
 			lastModified: entry.lastModified,
 			value: entry.value,
 			cacheState: "stale",
@@ -147,10 +149,29 @@ var MemoryCacheHandler = class {
 		this.currentMemoryCacheSize += entrySize;
 		this.evictLeastRecentlyUsed();
 	}
-	async revalidateTag(tags) {
+	async revalidateTag(tags, durations) {
 		const tagList = Array.isArray(tags) ? tags : [tags];
 		const now = Date.now();
-		for (const tag of tagList) this.tagRevalidatedAt.set(tag, now);
+		for (const tag of tagList) {
+			const existing = this.tagsManifest.get(tag) ?? {};
+			if (durations) this.tagsManifest.set(tag, {
+				...existing,
+				stale: now,
+				...durations.expire === void 0 ? {} : { expired: now + durations.expire * 1e3 }
+			});
+			else this.tagsManifest.set(tag, {
+				...existing,
+				expired: now
+			});
+		}
+	}
+	isTagExpired(tag, lastModified, now) {
+		const expired = this.tagsManifest.get(tag)?.expired;
+		return expired !== void 0 && expired <= now && expired >= lastModified;
+	}
+	isTagStale(tag, lastModified) {
+		const stale = this.tagsManifest.get(tag)?.stale;
+		return stale !== void 0 && stale > lastModified;
 	}
 	resetRequestCache() {}
 };
@@ -167,7 +188,7 @@ var LazyDataCacheHandler = class {
 		this.load = load;
 	}
 	resolve() {
-		return this.resolved ??= this.load().then(() => {
+		return this.resolved ??= shareIsolatePromise(this.load().then(() => {
 			const registered = globalHandlers[HANDLER_KEY];
 			if (registered && registered !== this) {
 				this.loadedHandler = registered;
@@ -179,7 +200,7 @@ var LazyDataCacheHandler = class {
 			delete globalHandlers[LAZY_HANDLER_KEY];
 			this.loadedHandler = fallback;
 			return fallback;
-		});
+		}));
 	}
 	async get(key, ctx) {
 		return (await this.resolve()).get(key, ctx);

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

@@ -23,9 +23,19 @@ export type UnstableCacheObservation = Readonly<{
 export type CacheLifeSink = {
   cacheLife: CacheLifeConfig | null;
 };
+type TagInvalidationDurations = {
+  expire?: number;
+} | undefined;
+/** A CDN purge waiting for the request boundary, after its data-cache invalidation. */
+export type PendingCdnTagInvalidation = Readonly<{
+  tag: string;
+  durations: TagInvalidationDurations;
+  dataInvalidation: Promise<void>;
+}>;
 export type CacheState = {
   actionRevalidationKind: ActionRevalidationKind;
   cacheLifeSink: CacheLifeSink | null;
+  pendingCdnTagInvalidations: PendingCdnTagInvalidation[];
   pendingRevalidatedTags: Set<string>;
   pendingRevalidations: Set<Promise<void>>;
   requestScopedCacheLife: CacheLifeConfig | null;
@@ -56,9 +66,36 @@ export declare function _hasPendingRevalidatedTag(tags: readonly string[]): bool
  */
 export declare function _queuePendingRevalidation(promise: Promise<void>): boolean;
 /**
- * Await and clear every cache invalidation queued in the current request.
- * Clearing before awaiting also lets a later drain observe work enqueued by
- * an async continuation while this batch is settling.
+ * Defer the CDN purge for `tag` to the current Server Action or Route Handler
+ * boundary, so the request sends one adapter call per cacheLife profile like
+ * Next.js' `executeRevalidates`. Edge purges are rate limited (Workers Cache
+ * allows 5 requests a minute per account), so per-call purges run out fast.
+ *
+ * Only those two phases defer: their executors always drain before the
+ * request finishes. Once the response has closed, `after()` callbacks run
+ * past the last drain, so they purge immediately too. Everywhere else returns
+ * false and the caller purges immediately.
+ *
+ * @internal
+ */
+export declare function _queuePendingCdnTagInvalidation(tag: string, durations: TagInvalidationDurations, dataInvalidation: Promise<void>): boolean;
+/**
+ * Ask the CDN adapter to invalidate `tags`, logging rather than rethrowing a
+ * failure. The data cache is already invalidated by then, so a failed edge
+ * purge leaves edge-cached responses stale until they expire, and failing the
+ * request would not change that. It would only report a committed Server
+ * Action write as a failure.
+ *
+ * @internal
+ */
+export declare function _revalidateCdnTags(tags: string | string[], durations?: {
+  expire?: number;
+}): Promise<void>;
+/**
+ * Await and clear every cache invalidation queued in the current request,
+ * then send the deferred CDN purges in batches. Clearing before awaiting also
+ * lets a later drain observe work enqueued by an async continuation while
+ * this batch is settling.
  *
  * @internal
  */

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

@@ -1,5 +1,6 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
+import { getCdnCacheAdapter } from "./cdn-cache.js";
 import { getHeadersAccessPhase } from "./internal/headers-state.js";
 import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
 //#region src/shims/cache-request-state.ts
@@ -48,6 +49,7 @@ const ACTION_DID_REVALIDATE_DYNAMIC_ONLY = 2;
 const fallbackState = globalState[FALLBACK_KEY] ??= {
 	actionRevalidationKind: ACTION_DID_NOT_REVALIDATE,
 	cacheLifeSink: null,
+	pendingCdnTagInvalidations: [],
 	pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 	pendingRevalidations: /* @__PURE__ */ new Set(),
 	requestScopedCacheLife: null,
@@ -69,6 +71,7 @@ function _runWithCacheState(fn) {
 	const state = {
 		actionRevalidationKind: ACTION_DID_NOT_REVALIDATE,
 		cacheLifeSink: null,
+		pendingCdnTagInvalidations: [],
 		pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 		pendingRevalidations: /* @__PURE__ */ new Set(),
 		requestScopedCacheLife: null,
@@ -128,9 +131,69 @@ function _queuePendingRevalidation(promise) {
 	return true;
 }
 /**
-* Await and clear every cache invalidation queued in the current request.
-* Clearing before awaiting also lets a later drain observe work enqueued by
-* an async continuation while this batch is settling.
+* Defer the CDN purge for `tag` to the current Server Action or Route Handler
+* boundary, so the request sends one adapter call per cacheLife profile like
+* Next.js' `executeRevalidates`. Edge purges are rate limited (Workers Cache
+* allows 5 requests a minute per account), so per-call purges run out fast.
+*
+* Only those two phases defer: their executors always drain before the
+* request finishes. Once the response has closed, `after()` callbacks run
+* past the last drain, so they purge immediately too. Everywhere else returns
+* false and the caller purges immediately.
+*
+* @internal
+*/
+function _queuePendingCdnTagInvalidation(tag, durations, dataInvalidation) {
+	const phase = getHeadersAccessPhase();
+	if (phase !== "action" && phase !== "route-handler") return false;
+	if (isInsideUnifiedScope() && getRequestContext().afterContext.responseClosed) return false;
+	getCacheState().pendingCdnTagInvalidations.push({
+		tag,
+		durations,
+		dataInvalidation
+	});
+	return true;
+}
+/**
+* Ask the CDN adapter to invalidate `tags`, logging rather than rethrowing a
+* failure. The data cache is already invalidated by then, so a failed edge
+* purge leaves edge-cached responses stale until they expire, and failing the
+* request would not change that. It would only report a committed Server
+* Action write as a failure.
+*
+* @internal
+*/
+async function _revalidateCdnTags(tags, durations) {
+	try {
+		await getCdnCacheAdapter().revalidateTag(tags, durations);
+	} catch (error) {
+		console.error("[vinext] CDN cache invalidation failed; edge-cached responses may stay stale until they expire:", error);
+	}
+}
+async function flushCdnTagInvalidations(invalidations) {
+	if (invalidations.length === 0) return;
+	const settled = await Promise.allSettled(invalidations.map(({ dataInvalidation }) => dataInvalidation));
+	const batches = /* @__PURE__ */ new Map();
+	invalidations.forEach(({ tag, durations }, index) => {
+		if (settled[index].status === "rejected") return;
+		const key = durations === void 0 ? "" : JSON.stringify(durations);
+		let batch = batches.get(key);
+		if (!batch) {
+			batch = {
+				durations,
+				tags: /* @__PURE__ */ new Set()
+			};
+			batches.set(key, batch);
+		}
+		batch.tags.add(tag);
+	});
+	await Promise.all([...batches.values()].map(({ durations, tags }) => _revalidateCdnTags([...tags], durations)));
+}
+/**
+* Await and clear every cache invalidation queued in the current request,
+* then send the deferred CDN purges in batches. Clearing before awaiting also
+* lets a later drain observe work enqueued by an async continuation while
+* this batch is settling.
 *
 * @internal
 */
@@ -138,14 +201,16 @@ async function _drainPendingRevalidations() {
 	const state = getCacheState();
 	let didReject = false;
 	let firstRejection;
-	while (state.pendingRevalidations.size > 0) {
+	while (state.pendingRevalidations.size > 0 || state.pendingCdnTagInvalidations.length > 0) {
 		const pending = [...state.pendingRevalidations];
 		state.pendingRevalidations.clear();
+		const cdnInvalidations = state.pendingCdnTagInvalidations.splice(0);
 		const results = await Promise.allSettled(pending);
 		for (const result of results) if (result.status === "rejected" && !didReject) {
 			didReject = true;
 			firstRejection = result.reason;
 		}
+		await flushCdnTagInvalidations(cdnInvalidations);
 	}
 	if (didReject) throw firstRejection;
 }
@@ -220,4 +285,4 @@ 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, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, getRegisteredCacheContext, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry };

package/dist/shims/cache-runtime.js

@@ -3,17 +3,19 @@ import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation }
 import { VINEXT_RSC_MARKER_HEADER } from "../server/headers.js";
 import { workUnitAsyncStorage } from "./internal/work-unit-async-storage.js";
 import { isRouteCacheabilityProbe, recordRouteCacheabilityProbeBailout } from "./cacheability-classification.js";
+import { shareIsolatePromise } from "../server/isolate-shared-promise.js";
 import { getDataCacheHandler } from "./cache-handler.js";
 import { addCollectedRequestTags, getCurrentFetchSoftTags, runWithDetachedFetchObservations } from "./fetch-cache-state.js";
 import { suppressHangingPromiseAbortRejections } from "./internal/make-hanging-promise.js";
 import { createPprFallbackShellSuspensePromise, trackPprFallbackShellCacheTask } from "./ppr-fallback-shell.js";
-import { markDynamicUsage, throwIfInsideCacheScope } from "./internal/headers-state.js";
+import { createUseCacheAccessError, markDynamicUsage, recordInvalidDynamicUsageError } from "./internal/headers-state.js";
 import { isDraftModeEnabled } from "./headers.js";
 import { _registerCacheContextAccessor } from "./internal/cache-context-accessor.js";
 import { _hasPendingRevalidatedTag, _setRequestScopedCacheLife, cacheLifeProfiles, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
 import "./fetch-cache.js";
 import { hasUseCacheLayoutMarker, hasUseCachePageMarker, isUseCacheFunctionReference, withoutUseCacheSegmentMarker } from "./internal/app-page-props-cache-key.js";
-import { getFallbackParamsSnapshot, makeThenableParams, restoreThenableParams } from "./thenable-params.js";
+import { isWellKnownProperty } from "./internal/thenable-well-known-properties.js";
+import { getFallbackParamsSnapshot, restoreThenableParams } from "./thenable-params.js";
 import { getCurrentRootParams } from "./root-params.js";
 import { flightArgumentsKey, restoreFlightReply, snapshotFlightReply } from "./cache-flight-arguments.js";
 import { cache } from "react";
@@ -132,7 +134,7 @@ function buildUseCacheKey(id, keySeed, argsKey) {
 }
 let _rscModule;
 function getRscModule() {
-	return _rscModule ??= import("@vitejs/plugin-rsc/react/rsc");
+	return _rscModule ??= shareIsolatePromise(import("@vitejs/plugin-rsc/react/rsc"));
 }
 /** Collect a ReadableStream<Uint8Array> into a single Uint8Array. */
 async function collectStream(stream) {
@@ -365,9 +367,9 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 					...props,
 					params: restoreThenableParams(await props.params, outerParams)
 				});
-				if (pagePropsIndex !== void 0) callArgs = withErroringPageSearchParams(callArgs, pagePropsIndex);
 			}
-			if (fallbackParams) return (await executeWithContext(fn, callArgs, cacheVariant, rsc)).result;
+			const callFn = segmentPropsIndex !== -1 && pagePropsIndex !== void 0 ? withErroringPageSearchParams(fn, pagePropsIndex) : fn;
+			if (fallbackParams) return (await executeWithContext(callFn, callArgs, cacheVariant, rsc)).result;
 			if (cacheVariant === "private") {
 				const privateCache = _getPrivateState()._privateCache;
 				const privateHit = privateCache.get(cacheKey);
@@ -375,11 +377,11 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 					if (privateHit.serialized) return rsc.createFromReadableStream(uint8ToStream(base64ToUint8(privateHit.serialized.body)), {}, { preserveServerReferences: true });
 					return privateHit.result;
 				}
-				const execution = await executeWithContext(fn, callArgs, cacheVariant, rsc);
+				const execution = await executeWithContext(callFn, callArgs, cacheVariant, rsc);
 				if (execution.cacheable) privateCache.set(cacheKey, execution);
 				return execution.result;
 			}
-			if (isDev || isDraftModeEnabled()) return (await executeWithContext(fn, callArgs, cacheVariant, rsc)).result;
+			if (isDev || isDraftModeEnabled()) return (await executeWithContext(callFn, callArgs, cacheVariant, rsc)).result;
 			const handler = getDataCacheHandler();
 			const rootParams = getCurrentRootParams();
 			const knownRootParamNames = knownRootParamsByFunctionId.get(id);
@@ -409,7 +411,7 @@ function registerCachedFunction(fn, id, variant, options = {}) {
 				}
 			}
 			const generate = async (propagate) => {
-				const { result, ctx, effectiveLife, collectedResult } = await runCachedFunctionWithContext(fn, callArgs, cacheVariant, (value) => serializeCacheResult(value, rsc));
+				const { result, ctx, effectiveLife, collectedResult } = await runCachedFunctionWithContext(callFn, callArgs, cacheVariant, (value) => serializeCacheResult(value, rsc));
 				const rootParamNames = ctx.readRootParamNames && ctx.readRootParamNames.size > 0 ? addKnownRootParamNames(id, ctx.readRootParamNames) : knownRootParamsByFunctionId.get(id);
 				if (propagate) {
 					recordRequestScopedCacheLife(effectiveLife);
@@ -631,18 +633,44 @@ function toReplayablePageArgs(args, index) {
 	return replaceArgument(args, index, pageProps);
 }
 /**
-* 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`.
+* Run `fn` with an erroring `searchParams` in the page props at `index` when
+* they have none (they are omitted from a public page cache's arguments, and
+* from a Response Store replay of them), 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 withErroringPageSearchParams(fn, index) {
+	return (...args) => {
+		const props = args[index];
+		if (!isPagePropsObject(props) || "searchParams" in props) return fn(...args);
+		return fn(...replaceArgument(args, index, {
+			...props,
+			searchParams: makeErroringPageSearchParams()
+		}));
+	};
+}
+function isNextWellKnownProperty(prop) {
+	return prop !== "value" && prop !== "error" && isWellKnownProperty(prop);
+}
+/**
+* Ported from Next.js's `makeErroringSearchParamsForUseCache`
+* (server/request/search-params.ts): reading `then` or a param throws, and
+* everything else reads the underlying promise, with methods bound to it.
+*/
+function makeErroringPageSearchParams() {
+	const cacheContext = cacheContextStorage.getStore() ?? null;
+	const requestContext = isInsideUnifiedScope() ? getRequestContext() : null;
+	const promise = Promise.resolve({});
+	return new Proxy(promise, { get(target, prop, receiver) {
+		if (!Object.hasOwn(target, prop) && typeof prop === "string" && (prop === "then" || !isNextWellKnownProperty(prop))) {
+			const error = createUseCacheAccessError("searchParams");
+			if (cacheContext) cacheContext.invalidDynamicUsageError ??= error;
+			const activeCacheContext = cacheContextStorage.getStore();
+			if (activeCacheContext && activeCacheContext !== cacheContext) activeCacheContext.invalidDynamicUsageError ??= error;
+			if (requestContext) recordInvalidDynamicUsageError(requestContext, error);
+			throw error;
+		}
+		const value = Reflect.get(target, prop, receiver);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
 }
 //#endregion
 export { NestedDynamicUseCacheError, buildUseCacheKey, cacheContextStorage, clearPrivateCache, getCacheContext, isUseCacheFunction, memoizeInCacheScope, registerCachedFunction, replayCachedFunction, runWithPrivateCache };

package/dist/shims/cache.d.ts

@@ -1,6 +1,6 @@
 import { ExecutionContextLike, getRequestExecutionContext, runWithExecutionContext } from "./request-context.js";
 import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
-import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheLifeConfig, CacheLifeSink, CacheState, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
+import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheLifeConfig, CacheLifeSink, CacheState, PendingCdnTagInvalidation, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
 import { CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, registerDataCacheHandler, registerLazyDataCacheHandler, setCacheHandler, setDataCacheHandler } from "./cache-handler.js";
 //#region src/shims/cache.d.ts
 /**
@@ -142,4 +142,4 @@ type UnstableCacheOptions = {
  */
 export declare function unstable_cache<T extends (...args: any[]) => Promise<any>>(fn: T, keyParts?: string[], options?: UnstableCacheOptions): T;
 //#endregion
-export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CacheLifeConfig, CacheLifeSink, CacheState, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, type ExecutionContextLike, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, markActionRevalidation, unstable_noStore as noStore, recordUnstableCacheObservation, registerDataCacheHandler, registerLazyDataCacheHandler, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, ActionRevalidationKind, CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CacheLifeConfig, CacheLifeSink, CacheState, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, type ExecutionContextLike, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, PendingCdnTagInvalidation, UnstableCacheObservation, UnstableCacheRevalidationMode, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, markActionRevalidation, unstable_noStore as noStore, recordUnstableCacheObservation, registerDataCacheHandler, registerLazyDataCacheHandler, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry };