@vinext/cloudflare 1.0.1 → 1.1.0

package/dist/cache/cdn-adapter.runtime.d.ts

@@ -32,8 +32,12 @@ export declare class CloudflareCdnCacheAdapter implements CdnCacheAdapter {
   set(_key: string, _data: IncrementalCacheValue | null, _ctx?: Record<string, unknown>): Promise<void>;
   buildResponseIdentityHeaders(): CdnResponseHeaders;
   buildResponseHeaders(input: CdnCacheableHeaderInput): CdnResponseHeaders;
-  /** Purge edge-cached responses by tag via the request context's `cache.purge`. */
-  revalidateTag(tags: string | string[], _durations?: {
+  /**
+   * Invalidate edge-cached responses by tag via the request context's cache.
+   * Stale tags map to `cache.invalidate`, so the edge serves the stale response
+   * while it refetches; expired tags map to `cache.purge`.
+   */
+  revalidateTag(tags: string | string[], durations?: {
     expire?: number;
   }): Promise<void>;
 }

package/dist/cache/cdn-adapter.runtime.js

@@ -1,5 +1,6 @@
 import { VINEXT_CDN_BUILD_ID_HEADER, getVinextCdnBuildIdentity } from "./cdn-build-id.js";
 import { VINEXT_EXPECTED_WORKER_VERSION_HEADER } from "../version-headers.js";
+import { invalidateOrPurge, isStaleTagInvalidation } from "./workers-cache-invalidation.js";
 import { isNonCacheableCacheControl, splitCacheControlDirectives } from "vinext/shims/cdn-cache";
 import { getRequestExecutionContext } from "vinext/shims/request-context";
 import { fnv1a64 } from "vinext/internal/utils/hash";
@@ -28,6 +29,9 @@ import { fnv1a64 } from "vinext/internal/utils/hash";
 *   `Cloudflare-CDN-Cache-Control` is already CDN-scoped so `max-age` is the correct knob
 *   for the edge to honor max-age + stale-while-revalidate.
 * - `revalidateTag` purges the edge via the request context's `cache.purge({ tags })`.
+*   A stale-while-revalidate invalidation (`revalidateTag` with durations
+*   other than `expire: 0`) uses `cache.invalidate({ tags })` instead, so the
+*   edge keeps serving the stale response while it refetches in the background.
 *
 * Tags use fixed-size lowercase digests before emission and purge because
 * Workers Cache tags are case-insensitive printable ASCII, while Next.js tags
@@ -208,16 +212,22 @@ var CloudflareCdnCacheAdapter = class {
 			"Cache-Tag": cacheTag
 		};
 	}
-	/** Purge edge-cached responses by tag via the request context's `cache.purge`. */
-	async revalidateTag(tags, _durations) {
+	/**
+	* Invalidate edge-cached responses by tag via the request context's cache.
+	* Stale tags map to `cache.invalidate`, so the edge serves the stale response
+	* while it refetches; expired tags map to `cache.purge`.
+	*/
+	async revalidateTag(tags, durations) {
 		const cache = getWorkersCache();
 		if (!cache) return;
 		const tagList = (Array.isArray(tags) ? tags : [tags]).filter((t) => typeof t === "string");
 		if (tagList.length === 0) return;
-		const result = await cache.purge({ tags: tagList.map(encodeCloudflareCacheTag) });
+		const options = { tags: tagList.map(encodeCloudflareCacheTag) };
+		const operation = isStaleTagInvalidation(durations) ? "invalidate" : "purge";
+		const result = await (operation === "invalidate" ? invalidateOrPurge(cache, options) : cache.purge(options));
 		if (result?.success === false) {
 			const errors = result.errors.map(({ code, message }) => `${code}: ${message}`).join(", ");
-			throw new Error(`[vinext] Workers Cache purge failed${errors ? `: ${errors}` : ""}`);
+			throw new Error(`[vinext] Workers Cache ${operation} failed${errors ? `: ${errors}` : ""}`);
 		}
 	}
 };

package/dist/cache/cdn-adapter.worker.d.ts

@@ -18,6 +18,7 @@ type CachePurgeOptions = {
 export declare class VinextCachedResponse extends WorkerEntrypoint<unknown, unknown> {
   fetch(request: Request): Promise<Response>;
   purge(options: CachePurgeOptions): Promise<unknown>;
+  invalidate(options: CachePurgeOptions): Promise<unknown>;
 }
 /** Uncached response entrypoint retained for deployment readiness probes. */
 export declare class VinextUncachedResponse extends WorkerEntrypoint<unknown, unknown> {

package/dist/cache/cdn-adapter.worker.js

@@ -1,6 +1,8 @@
 import { VINEXT_CDN_BUILD_ID_HEADER, getVinextCdnBuildIdentity } from "./cdn-build-id.js";
 import { SHARED_RESPONSE_STAGE_HEADER, finalizeGatewayResponse } from "./browser-cache-policy.js";
+import { hasCacheMethod, invalidateOrPurge } from "./workers-cache-invalidation.js";
 import { VINEXT_PRERENDER_READINESS_PATH, VINEXT_RSC_VARY_HEADER } from "vinext/internal/server/headers";
+import { isNonCacheableCacheControl } from "vinext/shims/cdn-cache";
 import { WorkerEntrypoint } from "cloudflare:workers";
 import "vinext/internal/server/cloudflare-workers-tracing";
 import { loadVinextRequestStage } from "vinext/server/request-stage";
@@ -13,6 +15,7 @@ const AUTHORIZATION_TRANSPORT_HEADER = "x-vinext-internal-authorization";
 const REQUEST_CACHE_CONTROL_TRANSPORT_HEADER = "x-vinext-internal-request-cache-control";
 const REQUEST_CF_TRANSPORT_HEADER = "x-vinext-internal-request-cf";
 const REQUEST_PRAGMA_TRANSPORT_HEADER = "x-vinext-internal-request-pragma";
+const WARMUP_USER_AGENT = "vinext-cloudflare-cdn-warm";
 const RESPONSE_STAGE_WIRE_CACHE = {
 	bypass: "vinext-cloudflare-v1:bypass",
 	shared: "vinext-cloudflare-v1:shared"
@@ -91,9 +94,6 @@ function withWorkerHostRuntime(context, env) {
 function hasFetch(value) {
 	return value !== null && (typeof value === "object" || typeof value === "function") && "fetch" in value && typeof value.fetch === "function";
 }
-function hasPurge(value) {
-	return value !== null && (typeof value === "object" || typeof value === "function") && "purge" in value && typeof value.purge === "function";
-}
 function getResponseStageBinding(context, exportName, serializedInvocation) {
 	const binding = context.exports?.[exportName];
 	if (typeof binding !== "function") return null;
@@ -179,6 +179,31 @@ function restoreResponseStageRequest(request, requestUrl, requestMethod) {
 		request: restored
 	};
 }
+function isAppPageDocumentInvocation(invocation) {
+	const props = invocation.props;
+	return props !== null && typeof props === "object" && Reflect.get(props, "kind") === "app-page" && Reflect.get(props, "isRscRequest") === false;
+}
+/**
+* No client waits on a deployment warm-up. Workers Cache revalidates an entry
+* that has a validator with a conditional request, as it does the Response
+* Store's, and serves the stale entry meanwhile or fills an expired one.
+*/
+function rendersWholeDocument(request) {
+	return request.headers.get("user-agent") === WARMUP_USER_AGENT || request.headers.has("If-None-Match") || request.headers.has("If-Modified-Since");
+}
+/** Give a cacheable document a validator, so Workers Cache revalidates it conditionally. */
+function withRevalidationValidator(response) {
+	if (response.headers.has("ETag") || response.headers.has("Last-Modified")) return response;
+	const policy = response.headers.get("Cloudflare-CDN-Cache-Control") ?? response.headers.get("CDN-Cache-Control") ?? response.headers.get("Cache-Control");
+	if (policy === null || isNonCacheableCacheControl(policy)) return response;
+	const headers = new Headers(response.headers);
+	headers.set("Last-Modified", (/* @__PURE__ */ new Date()).toUTCString());
+	return new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
 function preventResponseCaching(response) {
 	const headers = new Headers(response.headers);
 	headers.set("Cache-Control", "no-store");
@@ -211,17 +236,28 @@ function hasTaggedCustomVary(response) {
 	if (!response.headers.get("Cache-Tag")) return false;
 	return (response.headers.get("Vary") ?? "").split(",").map((name) => name.trim().toLowerCase()).filter(Boolean).some((name) => !FRAMEWORK_RESPONSE_VARY_FIELDS.has(name));
 }
-function withResponseStagePurge(context) {
+/**
+* Workers Cache purges and invalidations only reach the calling entrypoint's
+* cache, so route both through the cache-bearing response entrypoint.
+*/
+function withResponseStageCache(context) {
 	const factory = context.exports?.[CACHED_RESPONSE_STAGE_EXPORT];
 	if (typeof factory !== "function") return context;
 	const fallback = context.cache;
 	return {
 		...context,
-		cache: { purge(options) {
-			const target = factory({ props: {} });
-			if (hasPurge(target)) return target.purge(options);
-			return hasPurge(fallback) ? fallback.purge(options) : void 0;
-		} }
+		cache: {
+			purge(options) {
+				const target = factory({ props: {} });
+				if (hasCacheMethod(target, "purge")) return target.purge(options);
+				return hasCacheMethod(fallback, "purge") ? fallback.purge(options) : void 0;
+			},
+			invalidate(options) {
+				const target = factory({ props: {} });
+				const targetCanUpdate = hasCacheMethod(target, "invalidate") || hasCacheMethod(target, "purge");
+				return invalidateOrPurge(targetCanUpdate ? target : fallback, options);
+			}
+		}
 	};
 }
 function getResponseStageInvocation(value, expectedCache) {
@@ -282,19 +318,29 @@ var VinextCachedResponse = class extends WorkerEntrypoint {
 		}));
 		if (invocation.expectedResponseStageBuildIdentity !== void 0 && invocation.expectedResponseStageBuildIdentity !== getVinextCdnBuildIdentity()) return stampResponseStageBuildIdentity(responseStageUnavailable());
 		const restored = restoreResponseStageRequest(request, invocation.requestUrl, invocation.requestMethod);
-		const response = await invokeResponseStage(restored.request, this.env, context, invocation);
-		return stampResponseStageBuildIdentity(restored.didAccessRequestCf() || hasTaggedCustomVary(response) ? preventResponseCaching(response) : response);
+		const isAppPageDocument = isAppPageDocumentInvocation(invocation);
+		const response = await invokeResponseStage(restored.request, this.env, context, isAppPageDocument && rendersWholeDocument(request) ? {
+			...invocation,
+			options: {
+				...invocation.options,
+				renderWholeDocument: true
+			}
+		} : invocation);
+		return stampResponseStageBuildIdentity(restored.didAccessRequestCf() || hasTaggedCustomVary(response) ? preventResponseCaching(response) : isAppPageDocument ? withRevalidationValidator(response) : response);
 	}
 	async purge(options) {
 		const cache = Reflect.get(this.ctx, "cache");
-		if (!hasPurge(cache)) return void 0;
+		if (!hasCacheMethod(cache, "purge")) return void 0;
 		return cache.purge(options);
 	}
+	async invalidate(options) {
+		return invalidateOrPurge(Reflect.get(this.ctx, "cache"), options);
+	}
 };
 /** Uncached response entrypoint retained for deployment readiness probes. */
 var VinextUncachedResponse = class extends WorkerEntrypoint {
 	async fetch(request) {
-		const context = withResponseStagePurge(withWorkerHostRuntime(this.ctx, this.env));
+		const context = withResponseStageCache(withWorkerHostRuntime(this.ctx, this.env));
 		const invocation = getResponseStageInvocation(context.props, "bypass");
 		if (!invocation) return stampResponseStageBuildIdentity(new Response("Invalid vinext response-stage invocation", {
 			status: 400,
@@ -308,7 +354,7 @@ var VinextUncachedResponse = class extends WorkerEntrypoint {
 var cdn_adapter_worker_default = { async fetch(request, env, context) {
 	request = stripUntrustedTransportHeaders(request);
 	const sharedResponses = /* @__PURE__ */ new Map();
-	const stageContext = withResponseStagePurge(withWorkerHostRuntime(context, env));
+	const stageContext = withResponseStageCache(withWorkerHostRuntime(context, env));
 	const dispatchResponseStage = async (stageRequest, props, options) => {
 		const expectedResponseStageBuildIdentity = getVinextCdnBuildIdentity();
 		const invocation = {

package/dist/cache/kv-data-adapter.d.ts

@@ -6,7 +6,11 @@ export type KvDataAdapterOptions = {
   binding?: string;
   /** Namespace prefix for cache keys (isolates multiple apps in one namespace). */
   appPrefix?: string;
-  /** Default KV `expirationTtl` in seconds. @default 2592000 (30 days) */
+  /**
+   * Default KV `expirationTtl` in seconds. An entry whose `expire` is longer,
+   * such as one cached with `cacheLife("max")`, keeps it for its `expire`.
+   * @default 2592000 (30 days)
+   */
   ttlSeconds?: number;
   /** TTL in milliseconds for the in-memory tag-invalidation cache. @default 5000 */
   tagCacheTtlMs?: number;

package/dist/cache/kv-data-adapter.runtime.js

@@ -293,7 +293,7 @@ var KVCacheHandler = class {
 			expireAt,
 			cacheControl
 		};
-		const expirationTtl = this.ttlSeconds;
+		const expirationTtl = typeof effectiveExpire === "number" && Number.isFinite(effectiveExpire) && effectiveExpire > this.ttlSeconds ? resolveKvExpirationTtlSeconds(Math.ceil(effectiveExpire)) : this.ttlSeconds;
 		const metadata = JSON.stringify({ tags }).length <= 1024 ? { tags } : void 0;
 		return this._put(this._entryKey(key), JSON.stringify(entry), {
 			expirationTtl,

package/dist/cache/response-store-adapter.worker.js

@@ -1,6 +1,6 @@
 import { SHARED_RESPONSE_STAGE_HEADER, finalizeGatewayResponse } from "./browser-cache-policy.js";
 import { captureResponseStoreDataRegeneration, runWithResponseStoreInvocation, setResponseStore } from "./response-store-data.runtime.js";
-import { VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER } from "vinext/internal/server/headers";
+import { VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_SPECIAL_ERROR_STATUS_HEADER } from "vinext/internal/server/headers";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER as VINEXT_RSC_VARY_HEADER$1, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, createCanonicalRscRequestHeaders, createCanonicalRscRequestUrl } from "vinext/internal/server/app-rsc-cache-busting";
 import { isNonCacheableCacheControl } from "vinext/shims/cdn-cache";
 import { loadVinextRequestStage } from "vinext/server/request-stage";
@@ -71,9 +71,9 @@ function restoreRequest(invocation) {
 }
 async function invokeRequestStage(request, env, ctx) {
 	const { handleRequestStage } = await loadVinextRequestStage();
-	return handleRequestStage(request, env, stageContext(ctx, env), (request, props, options) => invokeResponseStage(request, props, env, ctx, options.cache));
+	return handleRequestStage(request, env, stageContext(ctx, env), (request, props, options) => invokeResponseStage(request, props, env, ctx, { cache: options.cache }));
 }
-async function invokeResponseStage(request, props, env, ctx, cache, capture, invocation) {
+async function invokeResponseStage(request, props, env, ctx, stageOptions, capture, invocation) {
 	const context = stageContext(ctx, env);
 	const dispatchRequestStage = (request) => invokeRequestStage(request, env, ctx);
 	const { handleResponseStage } = await loadVinextResponseStage();
@@ -81,7 +81,7 @@ async function invokeResponseStage(request, props, env, ctx, cache, capture, inv
 		replayable: isReplayableInvocation(request, props),
 		serialized: serializeInvocation(request, props)
 	};
-	return runWithResponseStoreInvocation(storedInvocation.serialized, storedInvocation.replayable, () => handleResponseStage(request, env, context, props, dispatchRequestStage, { cache }), capture);
+	return runWithResponseStoreInvocation(storedInvocation.serialized, storedInvocation.replayable, () => handleResponseStage(request, env, context, props, dispatchRequestStage, stageOptions), capture);
 }
 function createVinextResponseStoreOptions(configuration) {
 	const locationHint = configuration?.locationHint;
@@ -94,7 +94,10 @@ function createVinextResponseStoreOptions(configuration) {
 		async regenerate(input, { env, ctx }) {
 			if (input.id === ROUTE_REVALIDATOR_ID) {
 				const invocation = parseInvocation(input.args.at(-1));
-				const response = await invokeResponseStage(restoreRequest(invocation), invocation.props, env, ctx, "shared");
+				const response = await invokeResponseStage(restoreRequest(invocation), invocation.props, env, ctx, {
+					cache: "shared",
+					renderWholeDocument: true
+				});
 				if (!isCacheable(response)) {
 					await response.body?.cancel().catch(() => {});
 					throw new Error("Vinext response-stage regeneration was not cacheable");
@@ -113,7 +116,7 @@ function createVinextResponseStoreOptions(configuration) {
 			if (input.id === "vinext:data" && typeof input.args[0] === "string") {
 				const invocation = parseInvocation(input.args.at(-1));
 				return captureResponseStoreDataRegeneration(input.args[0], async () => {
-					await (await invokeResponseStage(restoreRequest(invocation), invocation.props, env, ctx, "bypass")).body?.pipeTo(new WritableStream());
+					await (await invokeResponseStage(restoreRequest(invocation), invocation.props, env, ctx, { cache: "bypass" })).body?.pipeTo(new WritableStream());
 				});
 			}
 			throw new Error(`Unknown vinext response-store revalidator ${input.id}`);
@@ -152,15 +155,18 @@ function withoutRequestScopedHeaders(response, responseStageProps) {
 		statusText: response.statusText
 	});
 }
+function isStoredErrorStatus(status) {
+	return status === 401 || status === 403 || status === 404;
+}
 function isCacheable(response) {
 	const policy = response.headers.get("Cloudflare-CDN-Cache-Control") ?? response.headers.get("CDN-Cache-Control") ?? response.headers.get("Cache-Control");
-	return response.status >= 200 && (response.status < 400 || response.status === 404) && policy !== null && !isNonCacheableCacheControl(policy);
+	return response.status >= 200 && (response.status < 400 || isStoredErrorStatus(response.status)) && policy !== null && !isNonCacheableCacheControl(policy);
 }
 async function readStoredResponse(key) {
 	try {
 		const response = await responseStore.fetch(key);
 		const storeStatus = response.headers.get("X-Workers-Response-Store");
-		if (response.status >= 200 && response.status < 400 || response.status === 404 && (storeStatus === "BLOB-FRESH" || storeStatus === "BLOB-STALE")) return response;
+		if (response.status >= 200 && response.status < 400 || isStoredErrorStatus(response.status) && (storeStatus === "BLOB-FRESH" || storeStatus === "BLOB-STALE")) return response;
 		response.body?.cancel().catch(() => {});
 		if (response.status === 404 && storeStatus === "MISS") return null;
 		throw new Error(`Workers Response Store returned ${response.status}`);
@@ -195,7 +201,7 @@ function publicResponse(response, cacheStatus, responseStageProps, pendingAdmiss
 		headers.set("X-Vinext-Cache", publicCacheStatus);
 	}
 	const cacheControl = headers.get("Cache-Control");
-	if (pendingAdmission && (!cacheControl || !isNonCacheableCacheControl(cacheControl, "browser"))) headers.set("Cache-Control", "private, max-age=0, must-revalidate");
+	if (pendingAdmission && (!cacheControl || !isNonCacheableCacheControl(cacheControl, "browser"))) headers.set("Cache-Control", "no-store, must-revalidate");
 	return traceCachedResponseStart(new Response(response.body, {
 		headers,
 		status: response.status,
@@ -211,7 +217,7 @@ function createVinextResponseStoreHandler(store) {
 const handler = { async fetch(request, env, ctx) {
 	const context = stageContext(ctx, env);
 	const dispatchResponseStage = async (stageRequest, props, options) => {
-		if (options.cache === "bypass" || stageRequest.method !== "GET" && stageRequest.method !== "HEAD") return publicResponse(await invokeResponseStage(stageRequest, props, env, ctx, "bypass"), "BYPASS", props);
+		if (options.cache === "bypass" || stageRequest.method !== "GET" && stageRequest.method !== "HEAD") return publicResponse(await invokeResponseStage(stageRequest, props, env, ctx, { cache: "bypass" }), "BYPASS", props);
 		const identityRequest = options.cacheIdentity?.request ?? stageRequest;
 		const identityProps = options.cacheIdentity?.props ?? props;
 		const isWarmup = request.headers.get("user-agent") === WARMUP_USER_AGENT;
@@ -239,7 +245,10 @@ const handler = { async fetch(request, env, ctx) {
 		}
 		const capture = rscSeed ? { captureRscData: true } : isWarmup ? {} : { streamResponse: true };
 		const serializedInvocation = JSON.stringify(invocation);
-		const rendered = await invokeResponseStage(stageRequest, props, env, ctx, "shared", capture, {
+		const rendered = await invokeResponseStage(stageRequest, props, env, ctx, isWarmup ? {
+			cache: "shared",
+			renderWholeDocument: true
+		} : { cache: "shared" }, capture, {
 			replayable: isReplayableInvocation(stageRequest, props),
 			serialized: options.cacheIdentity ? serializeInvocation(stageRequest, props) : serializedInvocation
 		});
@@ -302,10 +311,11 @@ const handler = { async fetch(request, env, ctx) {
 			rscHeaders.set("Vary", VINEXT_RSC_VARY_HEADER$1);
 			applyRscCompatibilityIdHeader(rscHeaders);
 			applyRscDeploymentIdHeader(rscHeaders);
+			if (isStoredErrorStatus(rendered.status)) rscHeaders.set(VINEXT_SPECIAL_ERROR_STATUS_HEADER, String(rendered.status));
 			const serializedRscInvocation = JSON.stringify(rscInvocation);
 			await responseStore.put(rscKey, new Response(rscData, {
 				headers: rscHeaders,
-				status: 200
+				status: rendered.status >= 300 && rendered.status < 400 ? 200 : rendered.status
 			}), {
 				coalesce: true,
 				revalidator: {

package/dist/cache/response-store-data.runtime.d.ts

@@ -25,6 +25,7 @@ export declare class WorkersResponseStoreCacheHandler implements CacheHandler {
   constructor(store?: WorkersResponseStore);
   get(key: string, context?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
   set(key: string, value: IncrementalCacheValue | null, context?: Record<string, unknown>): Promise<void>;
+  private write;
   revalidateTag(tags: string | string[], durations?: {
     expire?: number;
   }): Promise<void>;

package/dist/cache/response-store-data.runtime.js

@@ -1,3 +1,4 @@
+import { isStaleTagInvalidation } from "./workers-cache-invalidation.js";
 import { encodeCloudflareCacheTag } from "./cdn-adapter.runtime.js";
 import { Buffer } from "node:buffer";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -136,8 +137,15 @@ function deferResponseStoreAdmission(response, complete) {
 }
 /** Re-render an invocation and return the exact rewritten data-cache entry. */
 async function captureResponseStoreDataRegeneration(key, callback) {
-	const scope = { targetKey: key };
-	await regenerationStorage.run(scope, callback);
+	const scope = {
+		sideWrites: [],
+		targetKey: key
+	};
+	try {
+		await regenerationStorage.run(scope, callback);
+	} finally {
+		while (scope.sideWrites.length) await Promise.allSettled(scope.sideWrites.splice(0));
+	}
 	if (!scope.captured) throw new Error(`vinext response-store regeneration did not rewrite data key ${key}`);
 	return scope.captured;
 }
@@ -180,7 +188,8 @@ function deserialize(value) {
 }
 function cachePolicy(revalidate, expire) {
 	if (revalidate === false || revalidate === void 0) return `public, max-age=${CACHE_MAX_AGE_SECONDS}`;
-	return `public, max-age=${Math.max(0, revalidate)}, stale-while-revalidate=${Math.max(0, (expire ?? revalidate) - revalidate)}`;
+	const staleSeconds = expire === void 0 ? CACHE_MAX_AGE_SECONDS : Math.max(0, expire - revalidate);
+	return `public, max-age=${Math.max(0, revalidate)}, stale-while-revalidate=${staleSeconds}`;
 }
 var WorkersResponseStoreCacheHandler = class {
 	store;
@@ -231,9 +240,9 @@ var WorkersResponseStoreCacheHandler = class {
 			const requestedStale = typeof requestedRevalidate === "number" && requestedRevalidate > 0 && age > requestedRevalidate * 1e3;
 			let cacheState;
 			if (response.headers.get(REPLAYABLE_HEADER) === "1") {
-				if (requestedStale) cacheState = "stale";
+				if (requestedStale && storeStatus !== "BLOB-STALE") cacheState = "stale";
 			} else if (typeof entry.cacheControl?.expire === "number" && age > entry.cacheControl.expire * 1e3) cacheState = "expired";
-			else if (requestedStale || typeof entry.cacheControl?.revalidate === "number" && entry.cacheControl.revalidate > 0 && age > entry.cacheControl.revalidate * 1e3) cacheState = "stale";
+			else if (requestedStale || storeStatus === "BLOB-STALE" || typeof entry.cacheControl?.revalidate === "number" && entry.cacheControl.revalidate > 0 && age > entry.cacheControl.revalidate * 1e3) cacheState = "stale";
 			return {
 				lastModified: entry.lastModified,
 				value: entry.value,
@@ -248,7 +257,13 @@ var WorkersResponseStoreCacheHandler = class {
 			return null;
 		}
 	}
-	async set(key, value, context) {
+	set(key, value, context) {
+		const write = this.write(key, value, context);
+		const regeneration = regenerationStorage.getStore();
+		if (regeneration && regeneration.targetKey !== key) regeneration.sideWrites.push(write);
+		return write;
+	}
+	async write(key, value, context) {
 		let revalidate = readCacheControlField(context, "revalidate");
 		if (value && "revalidate" in value) revalidate = value.revalidate;
 		if (revalidate === 0) return;
@@ -287,12 +302,14 @@ var WorkersResponseStoreCacheHandler = class {
 			...revalidator ? { [REPLAYABLE_HEADER]: "1" } : {}
 		} });
 		const regeneration = regenerationStorage.getStore();
-		if (regeneration) {
-			if (key === regeneration.targetKey) regeneration.captured = response;
+		if (regeneration?.targetKey === key) {
+			regeneration.captured = response;
 			return;
 		}
+		if (regeneration && !revalidator) return;
 		await this.store.put(await cacheRequest(key), response, {
 			...revalidator ? { revalidator } : {},
+			...revalidator?.id !== "vinext:cache-function" ? { expiryBehavior: "miss" } : {},
 			coalesce: true,
 			purgeExisting: true
 		});
@@ -300,7 +317,10 @@ var WorkersResponseStoreCacheHandler = class {
 	async revalidateTag(tags, durations) {
 		const encodedTags = (Array.isArray(tags) ? tags : [tags]).map(encodeCloudflareCacheTag);
 		if (!encodedTags.length) return;
-		if (durations?.expire && durations.expire > 0) await this.store.refresh({ tags: encodedTags });
+		if (isStaleTagInvalidation(durations)) await this.store.invalidate({
+			tags: encodedTags,
+			...durations?.expire === void 0 ? {} : { expire: durations.expire }
+		});
 		else await this.store.purge({ tags: encodedTags });
 	}
 };

package/dist/cache/static-assets-adapter.build.js

@@ -33,12 +33,13 @@ function writeCacheAsset(outputDir, index, key, kind, sourcePath, route, content
 	const id = cacheAssetId(key);
 	const extension = kind;
 	const policy = cacheControl(route);
+	const headers = kind !== "rsc" ? route.headers : route.responseStatus !== void 0 && route.headers?.location !== void 0 ? { location: route.headers.location } : void 0;
 	const metadata = {
 		kind,
 		lastModified: fs.statSync(sourcePath).mtimeMs,
 		...policy ? { cacheControl: policy } : {},
-		...kind !== "rsc" && route.headers ? { headers: route.headers } : {},
-		...kind !== "rsc" && route.responseStatus !== void 0 ? { status: route.responseStatus } : {}
+		...headers ? { headers } : {},
+		...route.responseStatus !== void 0 ? { status: route.responseStatus } : {}
 	};
 	fs.mkdirSync(outputDir, { recursive: true });
 	const outputPath = path.join(outputDir, `${id}.${extension}`);

package/dist/cache/static-assets-adapter.runtime.js

@@ -56,10 +56,10 @@ var StaticAssetsCacheAdapter = class {
 			kind: "APP_PAGE",
 			html: "",
 			rscData: await bodyResponse.arrayBuffer(),
-			headers: void 0,
+			headers: metadata.headers,
 			postponed: void 0,
 			prerendered: true,
-			status: void 0
+			status: metadata.status
 		};
 		else value = {
 			kind: "APP_ROUTE",

package/dist/cache/workers-cache-invalidation.d.ts

@@ -0,0 +1,30 @@
+//#region src/cache/workers-cache-invalidation.d.ts
+/**
+ * Workers Cache tag invalidation shared by the CDN adapter, its worker
+ * entrypoints, and the Response Store data adapter.
+ */
+type CacheInvalidationOptions = {
+  tags: string[];
+};
+type CacheMethodName = "invalidate" | "purge";
+type CacheMethods<Name extends CacheMethodName> = Record<Name, (options: CacheInvalidationOptions) => unknown>;
+/**
+ * Whether `revalidateTag` marks its tags stale rather than expiring them.
+ *
+ * Next.js marks a tag stale whenever durations are passed, and expires it
+ * immediately when they are absent (`updateTag`, `revalidatePath`, the legacy
+ * single-argument `revalidateTag`) or `expire` is 0.
+ * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/incremental-cache/file-system-cache.ts
+ */
+export declare function isStaleTagInvalidation(durations?: {
+  expire?: number;
+}): boolean;
+export declare function hasCacheMethod<Name extends CacheMethodName>(value: unknown, name: Name): value is CacheMethods<Name>;
+/**
+ * Mark matching Workers Cache responses stale so the edge keeps serving them
+ * while it refetches in the background. Local Miniflare does not implement
+ * `invalidate()` yet, so it falls back to a hard purge there. Returns
+ * `undefined` when the cache supports neither.
+ */
+export declare function invalidateOrPurge(cache: unknown, options: CacheInvalidationOptions): unknown;
+//#endregion

package/dist/cache/workers-cache-invalidation.js

@@ -0,0 +1,27 @@
+//#region src/cache/workers-cache-invalidation.ts
+/**
+* Whether `revalidateTag` marks its tags stale rather than expiring them.
+*
+* Next.js marks a tag stale whenever durations are passed, and expires it
+* immediately when they are absent (`updateTag`, `revalidatePath`, the legacy
+* single-argument `revalidateTag`) or `expire` is 0.
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/incremental-cache/file-system-cache.ts
+*/
+function isStaleTagInvalidation(durations) {
+	return durations !== void 0 && !(typeof durations.expire === "number" && durations.expire <= 0);
+}
+function hasCacheMethod(value, name) {
+	return value !== null && (typeof value === "object" || typeof value === "function") && name in value && typeof Reflect.get(value, name) === "function";
+}
+/**
+* Mark matching Workers Cache responses stale so the edge keeps serving them
+* while it refetches in the background. Local Miniflare does not implement
+* `invalidate()` yet, so it falls back to a hard purge there. Returns
+* `undefined` when the cache supports neither.
+*/
+function invalidateOrPurge(cache, options) {
+	if (hasCacheMethod(cache, "invalidate")) return cache.invalidate(options);
+	return hasCacheMethod(cache, "purge") ? cache.purge(options) : void 0;
+}
+//#endregion
+export { hasCacheMethod, invalidateOrPurge, isStaleTagInvalidation };

package/dist/cdn-warm.js

@@ -482,7 +482,7 @@ function validateBuildIdentity(response, expectedBuildId) {
 	return null;
 }
 function isExpectedTerminalStatus(status) {
-	return status >= 300 && status < 400 || status === 404;
+	return status >= 300 && status < 400 || status === 401 || status === 403 || status === 404;
 }
 function validateRscWarmResponse(response, expectedBuildId, expectedRscBuildId, requireCacheHit = false, statusSource = "cloudflare") {
 	const buildIdentityValidation = validateBuildIdentity(response, expectedBuildId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vinext/cloudflare",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Cloudflare cache and image adapters for vinext.",
   "homepage": "https://vinext.dev/",
   "license": "MIT",
@@ -48,21 +48,21 @@
     }
   },
   "dependencies": {
-    "@cloudflare/workers-response-store": "1.0.1"
+    "@cloudflare/workers-response-store": "1.1.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.2",
     "cf": "1.0.0-beta.1",
     "miniflare": "5.20260730.0-alpha",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.3.2",
-    "vite-plus": "0.3.2",
-    "vitest": "4.1.11",
-    "vinext": "1.0.1"
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
+    "vite-plus": "1.1.0",
+    "vitest": "5.0.3",
+    "vinext": "1.1.0"
   },
   "peerDependencies": {
     "@cloudflare/vite-plugin": "*",
     "cf": "*",
-    "vinext": "^1.0.1"
+    "vinext": "^1.1.0"
   },
   "peerDependenciesMeta": {
     "@cloudflare/vite-plugin": {