vinext 1.2.0 → 1.3.0

package/dist/server/worker-image-optimization.js

@@ -1,9 +1,7 @@
-import { isNextStaticPath } from "../utils/asset-prefix.js";
-import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { VINEXT_PRERENDER_SPECIAL_ERROR_HEADER } from "./headers.js";
-import { normalizePath } from "./normalize-path.js";
 import { readStaticFileSignal, readStaticFileSignalRequestHeaders } from "./static-file-signal.js";
 import { attachRequestCfMetadata, cloneRequestWithUrl } from "./request-pipeline.js";
+import { isNextStaticPath } from "../utils/asset-prefix.js";
 import { handleConfiguredImageOptimization, invalidImageSourceResponse, isImageSourceBodyStatus } from "./image-optimization.js";
 import { createStaticAssetRequest, mergeHeaders } from "./worker-utils.js";
 import { resolveClientBuildFile } from "./client-build-files.js";
@@ -28,19 +26,34 @@ function cancelResponseBody(response) {
 	body.cancel().catch(() => {});
 }
 /**
+* Return the pathname of the `_next/static` file a source's decoded pathname
+* names, or null. Next.js matches the decoded pathname against its
+* `.next/static` files literally, so a `.`, `..` or empty segment names no
+* file. The asset binding decodes each segment once, so each segment is
+* encoded once from the name checked here. Parsing the decoded pathname as a
+* URL again would resolve a segment that decoded to `%2E%2E` as `..`, outside
+* `_next/static`.
+*/
+function resolveNextStaticFile(decodedPathname, options) {
+	if (!isNextStaticPath(decodedPathname, options.basePath, options.assetPathPrefix)) return null;
+	const segments = decodedPathname.split("/").slice(1);
+	if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) return null;
+	return "/" + segments.map(encodeURIComponent).join("/");
+}
+/**
 * Fetch a local image source. Build output is fetched from the asset binding,
 * which serves it before the Worker and its middleware. Any other source is
 * served only when the application pipeline selects a public file for it.
 */
 async function fetchWorkerImageSource(imageUrl, request, options) {
 	const sourceUrl = new URL(imageUrl, request.url);
-	let sourcePathname;
+	let decodedPathname;
 	try {
-		sourcePathname = normalizePath(normalizePathnameForRouteMatchStrict(sourceUrl.pathname));
+		decodedPathname = decodeURIComponent(sourceUrl.pathname);
 	} catch {
 		return invalidImageSourceResponse();
 	}
-	const buildAssetPath = isNextStaticPath(sourcePathname, options.basePath, options.assetPathPrefix) ? sourcePathname : resolveClientBuildFile(sourceUrl.pathname, options.basePath, options.clientBuildFiles);
+	const buildAssetPath = resolveNextStaticFile(decodedPathname, options) ?? resolveClientBuildFile(sourceUrl.pathname, options.basePath, options.clientBuildFiles);
 	if (buildAssetPath !== null) return options.assets.fetch(new Request(new URL(buildAssetPath, request.url)));
 	const sourceResponse = await options.fetchPublicFile(attachRequestCfMetadata(new Request(sourceUrl, { signal: request.signal }), request));
 	if (sourceResponse && isImageSourceBodyStatus(sourceResponse.status)) return sourceResponse;

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/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 {
@@ -167,7 +168,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 +180,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 };

package/dist/shims/cache.js

@@ -3,7 +3,6 @@ import { getRequestContext, isInsideUnifiedScope } from "./unified-request-conte
 import { getRequestExecutionContext, runWithExecutionContext } from "./request-context.js";
 import { isInsideWorkStoreScope } from "./internal/work-store-scope.js";
 import { workUnitAsyncStorage } from "./internal/work-unit-async-storage.js";
-import { getCdnCacheAdapter } from "./cdn-cache.js";
 import { isStagedCacheabilityProbeActive } from "./cacheability-classification.js";
 import { MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, registerDataCacheHandler, registerLazyDataCacheHandler, setCacheHandler, setDataCacheHandler } from "./cache-handler.js";
 import { encodeCacheTag, encodeCacheTags } from "../utils/encode-cache-tag.js";
@@ -13,7 +12,8 @@ import { makeHangingPromise } from "./internal/make-hanging-promise.js";
 import { getHeadersAccessPhase, markDynamicUsage } from "./internal/headers-state.js";
 import { isDraftModeEnabled } from "./headers.js";
 import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
-import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _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, _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 { isPathKnownNotEdgeCached } from "./cdn-purge-routes.js";
 //#region src/shims/cache.ts
 /**
 * next/cache shim
@@ -69,7 +69,7 @@ function revalidateTag(tag, profile) {
 	if (!profile || !durations || durations.expire === 0) markActionRevalidation(1);
 	const encodedTag = encodeCacheTag(tag);
 	_markPendingRevalidatedTag(encodedTag);
-	return scheduleRevalidation(_invalidateEncodedTag(encodedTag, durations));
+	return scheduleTagInvalidation(encodedTag, durations);
 }
 /**
 * Invalidate one already-encoded tag across both cache layers.
@@ -79,10 +79,18 @@ function revalidateTag(tag, profile) {
 * default CDN adapter), THEN ask the CDN adapter to purge its edge (a no-op for
 * the default adapter). Purging the edge before the store is invalidated would
 * let the edge re-fetch and re-cache stale data.
+*
+* The data cache is invalidated right away, so reads later in the same action
+* see it. Inside a Server Action or Route Handler the purge waits for the
+* request boundary, which sends one batched adapter call per profile.
 */
-async function _invalidateEncodedTag(encoded, durations) {
+function scheduleTagInvalidation(encoded, durations) {
+	const dataInvalidation = invalidateDataCacheTag(encoded, durations);
+	if (_queuePendingCdnTagInvalidation(encoded, durations, dataInvalidation)) return scheduleRevalidation(dataInvalidation);
+	return scheduleRevalidation(dataInvalidation.then(() => _revalidateCdnTags(encoded, durations)));
+}
+async function invalidateDataCacheTag(encoded, durations) {
 	await getDataCacheHandler().revalidateTag(encoded, durations);
-	await getCdnCacheAdapter().revalidateTag(encoded, durations);
 }
 /**
 * Revalidate cached data associated with a specific path.
@@ -109,7 +117,8 @@ function revalidatePath(path, type) {
 	const tag = type ? `_N_T_${stem}/${type}` : `_N_T_${stem || "/"}`;
 	const encodedTag = encodeCacheTag(tag);
 	_markPendingRevalidatedTag(encodedTag);
-	return scheduleRevalidation(_invalidateEncodedTag(encodedTag));
+	if (isPathKnownNotEdgeCached(stem || "/")) return scheduleRevalidation(invalidateDataCacheTag(encodedTag));
+	return scheduleTagInvalidation(encodedTag);
 }
 /**
 * No-op shim for API compatibility.
@@ -140,7 +149,7 @@ function updateTag(tag) {
 	markActionRevalidation(1);
 	const encodedTag = encodeCacheTag(tag);
 	_markPendingRevalidatedTag(encodedTag);
-	return scheduleRevalidation(_invalidateEncodedTag(encodedTag));
+	return scheduleTagInvalidation(encodedTag);
 }
 /**
 * Opt out of static rendering and indicate a particular component should not be cached.
@@ -464,4 +473,4 @@ function unstable_cache(fn, keyParts, options) {
 	return cachedFn;
 }
 //#endregion
-export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, MemoryCacheHandler, NoOpCacheHandler, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLife, cacheLifeProfiles, cacheTag, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, io, isInsideUnstableCacheScope, markActionRevalidation, unstable_noStore as noStore, unstable_noStore, recordUnstableCacheObservation, refresh, registerDataCacheHandler, registerLazyDataCacheHandler, revalidatePath, revalidateTag, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry, unstable_cache, unstable_cacheLife, unstable_cacheTag, unstable_io, updateTag };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, MemoryCacheHandler, NoOpCacheHandler, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingCdnTagInvalidation, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _revalidateCdnTags, _runWithCacheState, _setRequestScopedCacheLife, cacheLife, cacheLifeProfiles, cacheTag, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, io, isInsideUnstableCacheScope, markActionRevalidation, unstable_noStore as noStore, unstable_noStore, recordUnstableCacheObservation, refresh, registerDataCacheHandler, registerLazyDataCacheHandler, revalidatePath, revalidateTag, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry, unstable_cache, unstable_cacheLife, unstable_cacheTag, unstable_io, updateTag };

package/dist/shims/cdn-purge-routes.d.ts

@@ -0,0 +1,24 @@
+//#region src/shims/cdn-purge-routes.d.ts
+type CdnPurgeRoute = {
+  patternParts: readonly string[];
+  routeSegments: readonly string[];
+};
+type CdnPurgeRoutes = {
+  metadataRoutes: readonly (Omit<CdnPurgeRoute, "patternParts"> & {
+    patternParts: readonly string[] | null;
+    servedUrl: string;
+  })[];
+  routes: readonly (CdnPurgeRoute & {
+    forceDynamic?: boolean;
+  })[];
+};
+/** Register the App Router's routes. Apps with a Pages Router never register. */
+export declare function registerCdnPurgeRoutes(routes: CdnPurgeRoutes): void;
+/**
+ * Whether no edge-cacheable response can carry the implicit tags of
+ * `revalidatePath(path)`, for any `type`. Paths that need encoding, the
+ * `/index` alias, and paths ending in a derived tag suffix (`/docs/page` is
+ * also the `/docs` page tag) always purge.
+ */
+export declare function isPathKnownNotEdgeCached(path: string): boolean;
+//#endregion

package/dist/shims/cdn-purge-routes.js

@@ -0,0 +1,77 @@
+import { matchRoutePatternPrefix, routePatternParts } from "../routing/route-pattern.js";
+//#region src/shims/cdn-purge-routes.ts
+/**
+* Build-time route facts that let `revalidatePath()` skip a CDN purge no
+* edge-cached response could match.
+*
+* Edge purges are rate limited (Workers Cache allows 5 a minute per account),
+* and a `dynamic = "force-dynamic"` App route never stores a response the
+* edge can serve. The check is conservative: it only skips a path when at
+* least one App route could serve it and every such route is force-dynamic.
+* The data cache is always invalidated.
+*/
+const CDN_PURGE_ROUTES_KEY = Symbol.for("vinext.cdnPurgeRoutes");
+const globals = globalThis;
+const DERIVED_TAG_SUFFIXES = /* @__PURE__ */ new Set([
+	"layout",
+	"page",
+	"route"
+]);
+/** Register the App Router's routes. Apps with a Pages Router never register. */
+function registerCdnPurgeRoutes(routes) {
+	globals[CDN_PURGE_ROUTES_KEY] = routes;
+}
+/** Whether some URL matched by `patternParts` starts with `pathParts`. */
+function canServeUnder(pathParts, patternParts) {
+	const last = patternParts.at(-1) ?? "";
+	const endsInCatchAll = last.startsWith(":") && (last.endsWith("+") || last.endsWith("*"));
+	if (patternParts.length < pathParts.length && !endsInCatchAll) return false;
+	return matchRoutePatternPrefix(pathParts, patternParts.slice(0, pathParts.length));
+}
+/**
+* Whether a response from `route` could carry a `revalidatePath(path)` tag.
+* Implicit tags use either the URL (`/blog/a`) or the route's segments
+* (`/(site)/blog/[slug]`), so check both as prefixes.
+*/
+function couldCarryPathTag(pathParts, route) {
+	return canServeUnder(pathParts, route.patternParts) || canServeUnder(pathParts, routePatternParts(route.routeSegments.join("/")));
+}
+/**
+* Whether a metadata route, or a child it generates (`/icon/small` from
+* `generateImageMetadata`, `/sitemap/0.xml` from `generateSitemaps`), could
+* carry a `revalidatePath(path)` tag.
+*/
+function metadataCouldCarryPathTag(pathParts, route) {
+	const patternParts = route.patternParts ?? routePatternParts(route.servedUrl);
+	const childParts = [
+		...patternParts.slice(0, -1),
+		(patternParts.at(-1) ?? "").replace(/\.[^.]*$/, ""),
+		":children*"
+	];
+	return couldCarryPathTag(pathParts, {
+		patternParts,
+		routeSegments: route.routeSegments
+	}) || canServeUnder(pathParts, childParts);
+}
+/**
+* Whether no edge-cacheable response can carry the implicit tags of
+* `revalidatePath(path)`, for any `type`. Paths that need encoding, the
+* `/index` alias, and paths ending in a derived tag suffix (`/docs/page` is
+* also the `/docs` page tag) always purge.
+*/
+function isPathKnownNotEdgeCached(path) {
+	const registered = globals[CDN_PURGE_ROUTES_KEY];
+	if (!registered || path === "/index" || /[^\x21-\x7e]|%/.test(path)) return false;
+	const pathParts = path.split("/").filter(Boolean);
+	if (DERIVED_TAG_SUFFIXES.has(pathParts.at(-1) ?? "")) return false;
+	if (registered.metadataRoutes.some((route) => metadataCouldCarryPathTag(pathParts, route))) return false;
+	let matched = false;
+	for (const route of registered.routes) {
+		if (!couldCarryPathTag(pathParts, route)) continue;
+		if (route.forceDynamic !== true) return false;
+		matched = true;
+	}
+	return matched;
+}
+//#endregion
+export { isPathKnownNotEdgeCached, registerCdnPurgeRoutes };

package/dist/shims/dynamic.js

@@ -52,13 +52,26 @@ function normalizeDynamicOptions(dynamicInput, options) {
 		...options
 	};
 }
-function createLazyComponent(loader) {
-	return React.lazy(async () => {
+function createLazyComponent(loader, share = (load) => load) {
+	return React.lazy(() => share((async () => {
 		const mod = await loader();
 		if (hasDefaultExport(mod)) return mod;
 		return { default: mod };
-	});
+	})()));
 }
+const SHARE_ISOLATE_PROMISE_KEY = Symbol.for("vinext.shareIsolatePromise");
+/**
+* The server React.lazy is created once per dynamic() call, so every request
+* in the isolate renders the same load. On Workers, the request that starts it
+* owns its I/O; if that request is canceled first, the load never settles and
+* every later render of the component hangs. The server installs
+* `shareIsolatePromise` on a global symbol, which keeps the starting request
+* alive until the load settles, without this shim importing request state.
+*/
+const shareServerLoad = (load) => {
+	const share = globalThis[SHARE_ISOLATE_PROMISE_KEY];
+	return share ? share(load) : load;
+};
 function useRetryableLazyComponent(loader, initialLazyComponent) {
 	const [LazyComponent, setLazyComponent] = React.useState(() => initialLazyComponent);
 	const [retryKey, setRetryKey] = React.useState(0);
@@ -218,7 +231,7 @@ function dynamic(dynamicInput, options) {
 			AsyncServerDynamic.displayName = "DynamicAsyncServer";
 			return AsyncServerDynamic;
 		}
-		const LazyServer = createLazyComponent(loader);
+		const LazyServer = createLazyComponent(loader, shareServerLoad);
 		const ServerDynamic = (props) => {
 			const isAppRouterTree = useIsAppRouterTree();
 			const fallback = LoadingComponent ? React.createElement(LoadingComponent, createDynamicLoadingProps()) : null;