@@ -230,6 +230,8 @@ Explicit provider headers remain a Cloudflare extension: `Cloudflare-CDN-Cache-C
 
 This setup is fast when an entry is present at the edge, but Workers Cache is distributed rather than one globally shared cache. A response cached in one region may still miss in another. Tiered caching can reduce this duplication, but without a durable response store a regional miss or eviction can require another render. The KV data cache is also eventually consistent.
 
+`revalidatePath()` and `revalidateTag()` purge the edge by tag. [Workers Cache purges](https://developers.cloudflare.com/workers/cache/purge/) use Cloudflare's Free-tier purge limits, which every Worker in the account shares. As in Next.js, vinext sends one batched purge per cacheLife profile at the end of a Server Action or Route Handler, not one per call. If a purge fails, for example because the rate limit is reached, vinext logs the error and the action still succeeds: the data cache is already invalidated, but edge-cached responses for those tags stay stale until they expire. A route that only needs the client to refetch dynamic data can call `refresh()`, which doesn't purge.
+
 Use `createWorkersCacheConfig()` to configure the response entrypoints and version metadata, and add the KV binding for the data adapter:
 
 ```ts
 
@@ -212,6 +212,10 @@ function toEdgeCacheControl(cacheControl: string): string {
 const MAX_CACHE_TAG_BYTES = 16 * 1024;
 const CACHE_TAG_PREFIX = "vinext-";
 
+// Cloudflare caps a tag purge or invalidation request at 100 tags.
+// https://developers.cloudflare.com/cache/how-to/purge-cache/#availability-and-limits
+const MAX_TAGS_PER_PURGE = 100;
+
 /** Encode a case-sensitive Next.js tag into a fixed Workers Cache tag. */
 export function encodeCloudflareCacheTag(tag: string): string {
   // Two domain-separated 64-bit rounds keep accidental collisions negligible
@@ -373,13 +377,32 @@ export class CloudflareCdnCacheAdapter implements CdnCacheAdapter {
     );
     if (tagList.length === 0) return;
 
-    const options = { tags: tagList.map(encodeCloudflareCacheTag) };
+    const encodedTags = [...new Set(tagList.map(encodeCloudflareCacheTag))];
     const operation = isStaleTagInvalidation(durations) ? "invalidate" : "purge";
-    const result = (await (operation === "invalidate"
-      ? invalidateOrPurge(cache, options)
-      : cache.purge(options))) as WorkersCachePurgeResult | undefined;
-    if (result?.success === false) {
-      const errors = result.errors.map(({ code, message }) => `${code}: ${message}`).join(", ");
+    const chunks: string[][] = [];
+    for (let i = 0; i < encodedTags.length; i += MAX_TAGS_PER_PURGE) {
+      chunks.push(encodedTags.slice(i, i + MAX_TAGS_PER_PURGE));
+    }
+    // Settle every chunk before reporting, so no started purge is left
+    // un-awaited (Workers can cancel it).
+    const settled = await Promise.allSettled(
+      chunks.map(
+        async (chunk) =>
+          (await (operation === "invalidate"
+            ? invalidateOrPurge(cache, { tags: chunk })
+            : cache.purge({ tags: chunk }))) as WorkersCachePurgeResult | undefined,
+      ),
+    );
+    const rejection = settled.find((result) => result.status === "rejected");
+    if (rejection) throw rejection.reason;
+    const failures = settled.flatMap((result) =>
+      result.status === "fulfilled" && result.value?.success === false ? [result.value] : [],
+    );
+    if (failures.length > 0) {
+      const errors = failures
+        .flatMap((result) => result.errors)
+        .map(({ code, message }) => `${code}: ${message}`)
+        .join(", ");
       throw new Error(`[vinext] Workers Cache ${operation} failed${errors ? `: ${errors}` : ""}`);
     }
   }
 
@@ -149,6 +149,9 @@ async function runInRouteHandlerRevalidationContext(
   const requestContext = createRequestContext({
     headersContext,
     executionContext: getRequestExecutionContext(),
+    // Regeneration runs the handler directly, so it needs the phase that
+    // executeAppRouteHandler() would have set for a live request.
+    phase: "route-handler",
     unstableCacheRevalidation: "foreground",
   });
 
 
@@ -423,10 +423,22 @@ async function executeAppRouteHandlerImpl(
         requiresCompletedResponseAdmission: isRouteCacheabilityEvaluation(),
       })
     ) {
-      const completed = await completeAppRouteHandlerResponse(response);
+      const completed = await completeAppRouteHandlerResponse(response).catch(
+        async (error: unknown) => {
+          // Drain what the body queued before it failed. The body error stays
+          // the response error, as the eager drain above does for handlers.
+          await _drainPendingRevalidations().catch(() => {});
+          throw error;
+        },
+      );
       response = completed.response;
       cleanupDeferredToBody = !completed.completed;
-      if (completed.completed) markRouteCacheabilityResponseBodyComplete();
+      if (completed.completed) {
+        markRouteCacheabilityResponseBodyComplete();
+        // The body's producer ran after the eager drain above, so it owns any
+        // next/cache invalidations it queued (incomplete bodies drain at cleanup).
+        await _drainPendingRevalidations();
+      }
       const dynamicUsedDuringCompletion = options.consumeDynamicUsage();
       dynamicUsedInHandler =
         handlerResult.didAccessDynamicRequest() ||
 
@@ -1,3 +1,4 @@
+import { getCdnCacheAdapter } from "./cdn-cache.js";
 import { getHeadersAccessPhase } from "./internal/headers-state.js";
 import { getOrCreateAls } from "./internal/als-registry.js";
 import {
@@ -45,9 +46,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;
@@ -66,6 +77,7 @@ export const ACTION_DID_REVALIDATE_DYNAMIC_ONLY = 2 satisfies ActionRevalidation
 const fallbackState = (globalState[FALLBACK_KEY] ??= {
   actionRevalidationKind: ACTION_DID_NOT_REVALIDATE,
   cacheLifeSink: null,
+  pendingCdnTagInvalidations: [],
   pendingRevalidatedTags: new Set<string>(),
   pendingRevalidations: new Set<Promise<void>>(),
   requestScopedCacheLife: null,
@@ -95,6 +107,7 @@ export function _runWithCacheState<T>(fn: () => T | Promise<T>): T | Promise<T>
   const state: CacheState = {
     actionRevalidationKind: ACTION_DID_NOT_REVALIDATE,
     cacheLifeSink: null,
+    pendingCdnTagInvalidations: [],
     pendingRevalidatedTags: new Set<string>(),
     pendingRevalidations: new Set<Promise<void>>(),
     requestScopedCacheLife: null,
@@ -170,26 +183,105 @@ export 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 function _queuePendingCdnTagInvalidation(
+  tag: string,
+  durations: TagInvalidationDurations,
+  dataInvalidation: Promise<void>,
+): boolean {
+  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
+ */
+export async function _revalidateCdnTags(
+  tags: string | string[],
+  durations?: { expire?: number },
+): Promise<void> {
+  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: readonly PendingCdnTagInvalidation[],
+): Promise<void> {
+  if (invalidations.length === 0) return;
+
+  const settled = await Promise.allSettled(
+    invalidations.map(({ dataInvalidation }) => dataInvalidation),
+  );
+  const batches = new Map<string, { durations: TagInvalidationDurations; tags: Set<string> }>();
+  invalidations.forEach(({ tag, durations }, index) => {
+    // Purging the edge for a tag whose data-cache invalidation failed would
+    // let the edge refetch and re-cache stale data.
+    if (settled[index].status === "rejected") return;
+    const key = durations === undefined ? "" : JSON.stringify(durations);
+    let batch = batches.get(key);
+    if (!batch) {
+      batch = { durations, tags: 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
  */
 export async function _drainPendingRevalidations(): Promise<void> {
   const state = getCacheState();
   let didReject = false;
   let firstRejection: unknown;
-  while (state.pendingRevalidations.size > 0) {
+  while (state.pendingRevalidations.size > 0 || state.pendingCdnTagInvalidations.length > 0) {
     const pending = [...state.pendingRevalidations];
     state.pendingRevalidations.clear();
+    // Mutate in place: shallow-cloned child scopes share this array.
+    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;
 }
 
@@ -30,7 +30,6 @@ import { workUnitAsyncStorage } from "./internal/work-unit-async-storage.js";
 import { makeHangingPromise } from "./internal/make-hanging-promise.js";
 import { isInsideWorkStoreScope } from "./internal/work-store-scope.js";
 import { encodeCacheTag, encodeCacheTags } from "../utils/encode-cache-tag.js";
-import { getCdnCacheAdapter } from "./cdn-cache.js";
 import { getDataCacheHandler, type CachedFetchValue } from "./cache-handler.js";
 import { getRequestExecutionContext } from "./request-context.js";
 import { isStagedCacheabilityProbeActive } from "./cacheability-classification.js";
@@ -44,7 +43,9 @@ import {
   ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC,
   _hasPendingRevalidatedTag,
   _markPendingRevalidatedTag,
+  _queuePendingCdnTagInvalidation,
   _queuePendingRevalidation,
+  _revalidateCdnTags,
   _setRequestScopedCacheLife,
   cacheLifeProfiles,
   getRegisteredCacheContext,
@@ -125,7 +126,7 @@ export function revalidateTag(tag: string, profile?: string | { expire?: number
   }
   const encodedTag = encodeCacheTag(tag);
   _markPendingRevalidatedTag(encodedTag);
-  return scheduleRevalidation(_invalidateEncodedTag(encodedTag, durations));
+  return scheduleTagInvalidation(encodedTag, durations);
 }
 
 /**
@@ -136,13 +137,24 @@ export function revalidateTag(tag: string, profile?: string | { expire?: number
  * 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(
+function scheduleTagInvalidation(encoded: string, durations?: { expire?: number }): undefined {
+  const dataInvalidation = invalidateDataCacheTag(encoded, durations);
+  if (_queuePendingCdnTagInvalidation(encoded, durations, dataInvalidation)) {
+    return scheduleRevalidation(dataInvalidation);
+  }
+  return scheduleRevalidation(dataInvalidation.then(() => _revalidateCdnTags(encoded, durations)));
+}
+
+async function invalidateDataCacheTag(
   encoded: string,
   durations?: { expire?: number },
 ): Promise<void> {
   await getDataCacheHandler().revalidateTag(encoded, durations);
-  await getCdnCacheAdapter().revalidateTag(encoded, durations);
 }
 
 /**
@@ -171,7 +183,7 @@ export function revalidatePath(path: string, type?: "page" | "layout"): undefine
   const tag = type ? `_N_T_${stem}/${type}` : `_N_T_${stem || "/"}`;
   const encodedTag = encodeCacheTag(tag);
   _markPendingRevalidatedTag(encodedTag);
-  return scheduleRevalidation(_invalidateEncodedTag(encodedTag));
+  return scheduleTagInvalidation(encodedTag);
 }
 
 /**
@@ -211,7 +223,7 @@ export function updateTag(tag: string): undefined {
   // Expire the tag immediately (same as revalidateTag without SWR)
   const encodedTag = encodeCacheTag(tag);
   _markPendingRevalidatedTag(encodedTag);
-  return scheduleRevalidation(_invalidateEncodedTag(encodedTag));
+  return scheduleTagInvalidation(encodedTag);
 }
 
 /**
 
@@ -113,6 +113,7 @@ export function createRequestContext(opts?: Partial<UnifiedRequestContext>): Uni
     headersContext: null,
     actionRevalidationKind: 0,
     cacheLifeSink: null,
+    pendingCdnTagInvalidations: [],
     pendingRevalidatedTags: new Set<string>(),
     pendingRevalidations: new Set<Promise<void>>(),
     dynamicUsageDetected: false,
@@ -388,7 +389,8 @@ export function runWithUnifiedStateMutation<T>(
   ensureRenderDynamicLatch(parentCtx);
   const childCtx = { ...parentCtx };
   // NOTE: This is a shallow clone. Object/array fields (afterContext, pendingSetCookies,
-  // serverInsertedHTMLCallbacks, currentRequestTags, ssrHeadChildren), Set
+  // serverInsertedHTMLCallbacks, currentRequestTags, ssrHeadChildren,
+  // pendingCdnTagInvalidations), Set
   // fields (renderRequestApiUsage, pendingRevalidatedTags, pendingRevalidations,
   // cacheableFetchUrls, dynamicFetchUrls),
   // Map fields (unstableCacheObservations, _privateCache),