@vinext/cloudflare 1.0.0 → 1.1.0

package/dist/cache/browser-cache-policy.d.ts

@@ -0,0 +1,7 @@
+//#region src/cache/browser-cache-policy.d.ts
+export type SharedResponseStage = {
+  headers: Headers;
+};
+export declare const SHARED_RESPONSE_STAGE_HEADER = "x-vinext-cloudflare-shared-response-stage";
+export declare function finalizeGatewayResponse(response: Response, sharedResponses: Map<string, SharedResponseStage>, cacheStatusHeader?: string): Response;
+//#endregion

package/dist/cache/browser-cache-policy.js

@@ -0,0 +1,39 @@
+import { NEXTJS_CACHE_HEADER, VINEXT_CACHE_HEADER } from "vinext/internal/server/headers";
+//#region src/cache/browser-cache-policy.ts
+const CLOUDFLARE_EDGE_POLICY_HEADER = "Cloudflare-CDN-Cache-Control";
+const SHARED_RESPONSE_STAGE_HEADER = "x-vinext-cloudflare-shared-response-stage";
+const PRIVATE_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
+	SHARED_RESPONSE_STAGE_HEADER,
+	CLOUDFLARE_EDGE_POLICY_HEADER.toLowerCase(),
+	"cdn-cache-control",
+	"cache-tag",
+	VINEXT_CACHE_HEADER.toLowerCase(),
+	NEXTJS_CACHE_HEADER.toLowerCase()
+]);
+function finalizeGatewayResponse(response, sharedResponses, cacheStatusHeader = "CF-Cache-Status") {
+	const provenance = response.headers.get(SHARED_RESPONSE_STAGE_HEADER);
+	const sharedResponse = provenance === null ? void 0 : sharedResponses.get(provenance);
+	const usedSharedResponseStage = sharedResponse !== void 0;
+	const sharedResponseStageCollision = provenance !== null && !usedSharedResponseStage;
+	if (!response.headers.has(CLOUDFLARE_EDGE_POLICY_HEADER) && !usedSharedResponseStage && !sharedResponseStageCollision) return response;
+	const headers = new Headers(response.headers);
+	headers.delete(SHARED_RESPONSE_STAGE_HEADER);
+	headers.delete(CLOUDFLARE_EDGE_POLICY_HEADER);
+	if (usedSharedResponseStage || sharedResponseStageCollision) {
+		for (const name of PRIVATE_RESPONSE_HEADERS) headers.delete(name);
+		if (sharedResponseStageCollision) headers.set("Cache-Control", "no-store");
+		else if (!headers.has("Cache-Control")) headers.set("Cache-Control", "private, max-age=0, must-revalidate");
+	}
+	const cacheStatus = sharedResponse?.headers.get(cacheStatusHeader);
+	if (cacheStatus) {
+		headers.set(VINEXT_CACHE_HEADER, cacheStatus);
+		headers.set(NEXTJS_CACHE_HEADER, cacheStatus);
+	}
+	return new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
+//#endregion
+export { SHARED_RESPONSE_STAGE_HEADER, finalizeGatewayResponse };

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,6 +1,7 @@
 import { VINEXT_CDN_BUILD_ID_HEADER, getVinextCdnBuildIdentity } from "./cdn-build-id.js";
 import { VINEXT_EXPECTED_WORKER_VERSION_HEADER } from "../version-headers.js";
-import { isNonCacheableCacheControl } from "vinext/shims/cdn-cache";
+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";
 //#region src/cache/cdn-adapter.runtime.ts
@@ -19,17 +20,18 @@ import { fnv1a64 } from "vinext/internal/utils/hash";
 *   cache headers, so there is nothing to persist at the origin.
 * - `buildResponseHeaders` emits the SWR policy as `Cloudflare-CDN-Cache-Control`
 *   (`public, max-age=…, stale-while-revalidate=…`) so the edge caches and
-*   revalidates. The inner response's `Cache-Control` is
-*   `public, max-age=0, must-revalidate` so a browser never serves a stored copy
-*   without revalidating against the edge; the uncached gateway changes that to
-*   `private, max-age=0, must-revalidate` before public egress so personalized
-*   request-stage headers cannot enter another shared cache. A `Cache-Tag`
+*   revalidates. Explicit endpoint Cache-Control is preserved for clients,
+*   independently of shared admission. Framework-managed responses default to
+*   `private, max-age=0, must-revalidate`. A `Cache-Tag`
 *   header lets entries be purged by tag. Note the edge directive uses `max-age`
 *   (not `s-maxage`):
 *   the framework computes the policy with `s-maxage` for shared caches, but
 *   `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
@@ -54,13 +56,13 @@ function getBuildIdentityResponseHeader() {
 	const buildId = getVinextCdnBuildIdentity();
 	return buildId ? { [VINEXT_CDN_BUILD_ID_HEADER]: buildId } : {};
 }
-/** Remove every response header whose cache semantics are owned by Cloudflare. */
-function clearCloudflareCdnResponseHeaders(cacheControl) {
+/** Disable shared caching while preserving an explicit client policy. */
+function clearCloudflareCdnResponseHeaders(cacheControl, browserCacheControl) {
 	return {
 		...getBuildIdentityResponseHeader(),
-		"Cache-Control": cacheControl,
+		"Cache-Control": browserCacheControl ?? cacheControl,
 		"CDN-Cache-Control": null,
-		"Cloudflare-CDN-Cache-Control": null,
+		"Cloudflare-CDN-Cache-Control": browserCacheControl !== void 0 && !isNonCacheableCacheControl(browserCacheControl) ? "no-store" : null,
 		"Cache-Tag": null
 	};
 }
@@ -99,7 +101,7 @@ const NO_STORE = "no-store";
 * revalidate (against the edge) rather than serving a stored copy — so the user
 * always sees edge-fresh content while still permitting conditional 304s.
 */
-const BROWSER_REVALIDATE = "public, max-age=0, must-revalidate";
+const BROWSER_REVALIDATE = "private, max-age=0, must-revalidate";
 /**
 * A concrete stale window (1 year) substituted for a value-less
 * `stale-while-revalidate`. The framework emits a bare `stale-while-revalidate`
@@ -119,8 +121,10 @@ const UNBOUNDED_SWR_SECONDS = 31536e3;
 * `public`.
 */
 function toEdgeCacheControl(cacheControl) {
-	const withMaxAge = cacheControl.replace(/\bs-maxage=/g, "max-age=").replace(/\bstale-while-revalidate\b(?!=)/g, `stale-while-revalidate=${UNBOUNDED_SWR_SECONDS}`);
-	return /\bpublic\b/.test(withMaxAge) ? withMaxAge : `public, ${withMaxAge}`;
+	const directives = splitCacheControlDirectives(cacheControl);
+	const hasSharedMaxAge = directives.some((directive) => /^s-maxage\s*=/i.test(directive));
+	const withMaxAge = directives.filter((directive) => !hasSharedMaxAge || !/^max-age\s*=/i.test(directive)).map((directive) => directive.replace(/^s-maxage\s*=/i, "max-age=").replace(/^stale-while-revalidate$/i, `stale-while-revalidate=${UNBOUNDED_SWR_SECONDS}`)).join(", ");
+	return directives.some((directive) => /^public$/i.test(directive)) ? withMaxAge : `public, ${withMaxAge}`;
 }
 /**
 * Cloudflare's `Cache-Tag` header budget is 16 KB total. Fixed-size digests let
@@ -197,27 +201,33 @@ var CloudflareCdnCacheAdapter = class {
 	buildResponseHeaders(input) {
 		if (input.pendingDynamicCheck) return clearCloudflareCdnResponseHeaders(NO_STORE);
 		if (!input.cacheControl) return clearCloudflareCdnResponseHeaders(NO_STORE);
-		if (isNonCacheableCacheControl(input.cacheControl)) return clearCloudflareCdnResponseHeaders(input.cacheControl);
+		if (isNonCacheableCacheControl(input.cacheControl)) return clearCloudflareCdnResponseHeaders(input.cacheControl, input.browserCacheControl);
 		const cacheTag = input.tags?.length ? formatCacheTag(input.tags) : null;
-		if (input.tags?.length && !cacheTag) return clearCloudflareCdnResponseHeaders(NO_STORE);
+		if (input.tags?.length && !cacheTag) return clearCloudflareCdnResponseHeaders(NO_STORE, input.browserCacheControl);
 		return {
 			...getBuildIdentityResponseHeader(),
-			"Cache-Control": BROWSER_REVALIDATE,
+			"Cache-Control": input.browserCacheControl ?? BROWSER_REVALIDATE,
 			"CDN-Cache-Control": null,
 			"Cloudflare-CDN-Cache-Control": toEdgeCacheControl(input.cacheControl),
 			"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,8 +18,9 @@ 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. Bypass and probe renders execute only here. */
+/** Uncached response entrypoint retained for deployment readiness probes. */
 export declare class VinextUncachedResponse extends WorkerEntrypoint<unknown, unknown> {
   fetch(request: Request): Promise<Response>;
 }

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

@@ -1,5 +1,7 @@
 import { VINEXT_CDN_BUILD_ID_HEADER, getVinextCdnBuildIdentity } from "./cdn-build-id.js";
-import { NEXTJS_CACHE_HEADER, VINEXT_CACHE_HEADER, VINEXT_PRERENDER_READINESS_PATH, VINEXT_RSC_VARY_HEADER } from "vinext/internal/server/headers";
+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";
@@ -13,8 +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 CLOUDFLARE_EDGE_POLICY_HEADER = "Cloudflare-CDN-Cache-Control";
-const SHARED_RESPONSE_STAGE_HEADER = "x-vinext-cloudflare-shared-response-stage";
+const WARMUP_USER_AGENT = "vinext-cloudflare-cdn-warm";
 const RESPONSE_STAGE_WIRE_CACHE = {
 	bypass: "vinext-cloudflare-v1:bypass",
 	shared: "vinext-cloudflare-v1:shared"
@@ -93,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;
@@ -181,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");
@@ -209,48 +232,32 @@ function markSharedResponseStage(response, provenanceToken, responseStageProps,
 		statusText: response.statusText
 	}), cacheStatus, responseStageProps);
 }
-function finalizeGatewayResponse(response, provenanceToken) {
-	const provenance = response.headers.get(SHARED_RESPONSE_STAGE_HEADER);
-	const usedSharedResponseStage = provenance === provenanceToken || provenance?.startsWith(`${provenanceToken}:`) === true;
-	const sharedResponseStageCollision = provenance !== null && !usedSharedResponseStage;
-	const cacheControl = response.headers.get("Cache-Control");
-	if (!response.headers.has(CLOUDFLARE_EDGE_POLICY_HEADER) && !usedSharedResponseStage && !sharedResponseStageCollision) return response;
-	const headers = new Headers(response.headers);
-	headers.delete(SHARED_RESPONSE_STAGE_HEADER);
-	headers.delete(CLOUDFLARE_EDGE_POLICY_HEADER);
-	if (usedSharedResponseStage || sharedResponseStageCollision) {
-		headers.delete("CDN-Cache-Control");
-		headers.delete("Cache-Tag");
-		headers.delete(VINEXT_CACHE_HEADER);
-		headers.delete(NEXTJS_CACHE_HEADER);
-		if (!cacheControl || !isNonCacheableCacheControl(cacheControl)) headers.set("Cache-Control", "private, max-age=0, must-revalidate");
-	}
-	if (usedSharedResponseStage && provenance?.startsWith(`${provenanceToken}:`)) {
-		const cacheStatus = decodeURIComponent(provenance.slice(provenanceToken.length + 1));
-		headers.set(VINEXT_CACHE_HEADER, cacheStatus);
-		headers.set(NEXTJS_CACHE_HEADER, cacheStatus);
-	}
-	return new Response(response.body, {
-		headers,
-		status: response.status,
-		statusText: response.statusText
-	});
-}
 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) {
@@ -311,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. Bypass and probe renders execute only here. */
+/** 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,
@@ -336,8 +353,8 @@ var VinextUncachedResponse = class extends WorkerEntrypoint {
 /** Uncached gateway: request routing and middleware always execute here. */
 var cdn_adapter_worker_default = { async fetch(request, env, context) {
 	request = stripUntrustedTransportHeaders(request);
-	const sharedResponseStageProvenance = crypto.randomUUID();
-	const stageContext = withResponseStagePurge(withWorkerHostRuntime(context, env));
+	const sharedResponses = /* @__PURE__ */ new Map();
+	const stageContext = withResponseStageCache(withWorkerHostRuntime(context, env));
 	const dispatchResponseStage = async (stageRequest, props, options) => {
 		const expectedResponseStageBuildIdentity = getVinextCdnBuildIdentity();
 		const invocation = {
@@ -349,6 +366,7 @@ var cdn_adapter_worker_default = { async fetch(request, env, context) {
 		};
 		const usesSharedCache = options.cache === "shared";
 		try {
+			if (!usesSharedCache && !isResponseStageReadinessRequest(stageRequest)) return stampResponseStageBuildIdentity(await invokeResponseStage(stageRequest, env, stageContext, invocation));
 			const serializedInvocation = JSON.stringify({
 				...invocation,
 				options: expectedResponseStageBuildIdentity === null ? options : {
@@ -360,14 +378,17 @@ var cdn_adapter_worker_default = { async fetch(request, env, context) {
 			if (!binding) return responseStageUnavailable();
 			const entrypointRequest = usesSharedCache ? await createCacheFacingRequest(stageRequest, serializedInvocation) : stageRequest;
 			const response = validateResponseStageBuildIdentity(await binding.fetch(entrypointRequest));
-			return usesSharedCache ? markSharedResponseStage(response, sharedResponseStageProvenance, props, true) : response;
+			if (!usesSharedCache) return response;
+			const shared = markSharedResponseStage(response, crypto.randomUUID(), props, true);
+			sharedResponses.set(shared.headers.get(SHARED_RESPONSE_STAGE_HEADER), { headers: new Headers(shared.headers) });
+			return shared;
 		} catch (error) {
 			if (isResponseStageReadinessRequest(stageRequest)) return responseStageUnavailable();
 			throw error;
 		}
 	};
 	const { handleRequestStage } = await loadVinextRequestStage();
-	return finalizeGatewayResponse(await handleRequestStage(request, env, stageContext, dispatchResponseStage), sharedResponseStageProvenance);
+	return finalizeGatewayResponse(await handleRequestStage(request, env, stageContext, dispatchResponseStage), sharedResponses);
 } };
 //#endregion
 export { VinextCachedResponse, VinextUncachedResponse, cdn_adapter_worker_default as default };

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

@@ -26,8 +26,6 @@ import { getRequestExecutionContext } from "vinext/shims/request-context";
 const DEFAULT_BINDING = "VINEXT_KV_CACHE";
 /** Prefix used by revalidatePath for path-based tags. */
 const PATH_TAG_PREFIX = "_N_T_";
-/** Max tag length to prevent KV key abuse. */
-const MAX_TAG_LENGTH = 256;
 /** The runtime rejects a lower `cacheTtl` with "Cache TTL must be at least 30". */
 const MIN_KV_CACHE_TTL_SECONDS = 30;
 /** Cloudflare caps a bulk `get()` at 100 keys per call. */
@@ -36,12 +34,12 @@ const KV_BULK_GET_LIMIT = 100;
 const BASE64_RE = /^[A-Za-z0-9+/]*={0,2}$/;
 /**
 * Validate a cache tag. Returns null if invalid.
-* Note: `:` is rejected because TAG_PREFIX and ENTRY_PREFIX use `:` as a
-* separator — allowing `:` in user tags could cause ambiguous key lookups.
+* Tags may already be header-encoded, so their length is not the raw API tag
+* length. The key builder bounds KV keys and safely handles colon tags.
 */
 function validateTag(tag) {
-	if (typeof tag !== "string" || tag.length === 0 || tag.length > MAX_TAG_LENGTH) return null;
-	if (/[\x00-\x1f\\:]/.test(tag)) return null;
+	if (typeof tag !== "string" || tag.length === 0) return null;
+	if (/[\x00-\x1f\\]/.test(tag)) return null;
 	return tag;
 }
 function readStringArrayField(ctx, field) {
@@ -295,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/kv-key.js

@@ -38,7 +38,7 @@ function normalizeAppPrefix(appPrefix) {
 }
 function buildStorageKey(prefix, categoryPrefix, logicalKey) {
 	const key = `${prefix}${categoryPrefix}${logicalKey}`;
-	if (kvKeyByteLength(key) <= KV_KEY_MAX_BYTES) return key;
+	if (!(categoryPrefix === TAG_PREFIX && logicalKey.includes(":")) && kvKeyByteLength(key) <= KV_KEY_MAX_BYTES) return key;
 	return `${prefix}${categoryPrefix}${HASHED_KEY_PREFIX}${fnv1a64(logicalKey)}`;
 }
 /** Create the deterministic key namespace for runtime cache operations. */

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

@@ -1,5 +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";
@@ -70,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();
@@ -80,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;
@@ -93,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");
@@ -112,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}`);
@@ -151,16 +155,20 @@ 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 && 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);
-		if (response.status >= 200 && response.status < 400) return response;
+		const storeStatus = response.headers.get("X-Workers-Response-Store");
+		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 && response.headers.get("X-Workers-Response-Store") === "MISS") return null;
+		if (response.status === 404 && storeStatus === "MISS") return null;
 		throw new Error(`Workers Response Store returned ${response.status}`);
 	} catch (error) {
 		console.error(JSON.stringify({
@@ -170,7 +178,7 @@ async function readStoredResponse(key) {
 		return null;
 	}
 }
-function publicResponse(response, cacheStatus, responseStageProps) {
+function publicResponse(response, cacheStatus, responseStageProps, pendingAdmission = false) {
 	const headers = new Headers(response.headers);
 	const publicCacheStatus = cacheStatus === "HIT" && headers.get("CF-Cache-Status") === "UPDATING" ? "UPDATING" : cacheStatus;
 	const ageBasis = /^(\d+):(\d+)$/.exec(headers.get(AGE_BASIS_HEADER) ?? "");
@@ -193,7 +201,7 @@ function publicResponse(response, cacheStatus, responseStageProps) {
 		headers.set("X-Vinext-Cache", publicCacheStatus);
 	}
 	const cacheControl = headers.get("Cache-Control");
-	if (!cacheControl || !isNonCacheableCacheControl(cacheControl)) 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,
@@ -209,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;
@@ -237,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
 		});
@@ -260,7 +271,7 @@ const handler = { async fetch(request, env, ctx) {
 					error: error instanceof Error ? error.message : String(error)
 				}));
 			}));
-			return publicResponse(rendered, "MISS", props);
+			return publicResponse(rendered, "MISS", props, true);
 		}
 		if (!isCacheable(rendered)) {
 			capture?.rscData?.catch(() => {});
@@ -300,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: {
@@ -315,7 +327,21 @@ const handler = { async fetch(request, env, ctx) {
 		return publicResponse(new Response(foreground, rendered), "MISS", props);
 	};
 	const { handleRequestStage } = await loadVinextRequestStage();
-	return handleRequestStage(request, env, context, dispatchResponseStage);
+	const sharedResponses = /* @__PURE__ */ new Map();
+	const dispatch = async (stageRequest, props, options) => {
+		const response = await dispatchResponseStage(stageRequest, props, options);
+		if (options.cache !== "shared") return response;
+		const headers = new Headers(response.headers);
+		const token = crypto.randomUUID();
+		headers.set(SHARED_RESPONSE_STAGE_HEADER, token);
+		sharedResponses.set(token, { headers: new Headers(headers) });
+		return new Response(response.body, {
+			headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+	};
+	return finalizeGatewayResponse(await handleRequestStage(request, env, context, dispatch), sharedResponses, "X-Vinext-Cache");
 } };
 //#endregion
 export { createVinextResponseStoreHandler, createVinextResponseStoreOptions };

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.d.ts

@@ -1,5 +1,5 @@
 //#region src/cache/static-assets-adapter.build.d.ts
-/** Package App Router prerender output as immutable Workers Static Assets. */
+/** Package prerender output from both routers as immutable Workers Static Assets. */
 export declare function finalizeStaticAssetsPrerenderOutput(root: string, options?: {
   clientOutDir?: string;
 }): number;

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

@@ -3,13 +3,23 @@ import fs from "node:fs";
 import path from "node:path";
 import { createHash } from "node:crypto";
 import { readPrerenderManifest } from "vinext/internal/server/prerender-manifest";
-import { appIsrCacheKey } from "vinext/internal/server/isr-cache";
+import { appIsrCacheKey, pagesIsrCacheKey } from "vinext/internal/server/isr-cache";
+import { extractVinextNextDataJson } from "vinext/internal/client/vinext-next-data";
 import { normalizePregeneratedPathname } from "vinext/internal/server/pregenerated-concrete-paths";
 import { getAppRouteOutputPath, getOutputPath, getRscOutputPath } from "vinext/internal/utils/prerender-output-paths";
 //#region src/cache/static-assets-adapter.build.ts
 function cacheAssetId(key) {
 	return createHash("sha256").update(key).digest("hex");
 }
+function pagesCacheKey(pathname, locale, buildId) {
+	let pagesPathname = new URL(`https://vinext.invalid${pathname}`).pathname;
+	if (locale) {
+		const prefix = `/${locale}`;
+		if (pagesPathname === prefix) pagesPathname = "/";
+		else if (pagesPathname.startsWith(`${prefix}/`)) pagesPathname = pagesPathname.slice(prefix.length);
+	}
+	return pagesIsrCacheKey(pagesPathname, buildId, locale ? `locale:${locale}` : void 0);
+}
 function cacheControl(route) {
 	if (route.revalidate === void 0) return void 0;
 	return {
@@ -18,24 +28,27 @@ function cacheControl(route) {
 		...route.stale === void 0 ? {} : { stale: route.stale }
 	};
 }
-function writeCacheAsset(outputDir, index, key, kind, sourcePath, route) {
+function writeCacheAsset(outputDir, index, key, kind, sourcePath, route, contents) {
 	if (!fs.existsSync(sourcePath)) return false;
 	const id = cacheAssetId(key);
-	const extension = kind === "html" ? "html" : kind === "rsc" ? "rsc" : "route";
+	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 });
-	fs.copyFileSync(sourcePath, path.join(outputDir, `${id}.${extension}`));
+	const outputPath = path.join(outputDir, `${id}.${extension}`);
+	if (contents === void 0) fs.copyFileSync(sourcePath, outputPath);
+	else fs.writeFileSync(outputPath, contents);
 	index[id] = metadata;
 	return true;
 }
-/** Package App Router prerender output as immutable Workers Static Assets. */
+/** Package prerender output from both routers as immutable Workers Static Assets. */
 function finalizeStaticAssetsPrerenderOutput(root, options = {}) {
 	const serverDir = path.join(root, "dist", "server");
 	const prerenderDir = path.join(serverDir, "prerendered-routes");
@@ -56,6 +69,31 @@ function finalizeStaticAssetsPrerenderOutput(root, options = {}) {
 		if (route.router === "app") {
 			count += Number(writeCacheAsset(outputDir, index, appIsrCacheKey(cachePathname, "html", manifest.buildId), "html", path.join(prerenderDir, getOutputPath(pathname, manifest.trailingSlash ?? false)), route));
 			count += Number(writeCacheAsset(outputDir, index, appIsrCacheKey(cachePathname, "rsc", manifest.buildId), "rsc", path.join(prerenderDir, getRscOutputPath(pathname)), route));
+		} else if (route.router === "pages") {
+			const sourcePath = path.join(prerenderDir, getOutputPath(pathname, manifest.trailingSlash ?? false));
+			if (!fs.existsSync(sourcePath)) continue;
+			const html = fs.readFileSync(sourcePath, "utf8");
+			const key = pagesCacheKey(pathname, route.locale, manifest.buildId);
+			if (route.notFound) {
+				count += Number(writeCacheAsset(outputDir, index, key, "not-found", sourcePath, route, "null"));
+				continue;
+			}
+			if (route.redirectProps) {
+				count += Number(writeCacheAsset(outputDir, index, key, "redirect", sourcePath, route, JSON.stringify(route.redirectProps)));
+				continue;
+			}
+			const json = extractVinextNextDataJson(html);
+			if (json === null) continue;
+			const nextData = JSON.parse(json);
+			if (nextData.gsp !== true && nextData.autoExport !== true) continue;
+			if (!nextData.props || typeof nextData.props !== "object") throw new Error(`[vinext] Missing prerendered Pages props for ${pathname}`);
+			count += Number(writeCacheAsset(outputDir, index, pagesCacheKey(pathname, nextData.locale ?? route.locale, manifest.buildId), "pages", sourcePath, {
+				...route,
+				responseStatus: route.route === "/404" ? 404 : route.route === "/500" ? 500 : route.responseStatus ?? 200
+			}, JSON.stringify({
+				html,
+				pageData: nextData.props
+			})));
 		} else if (route.router === "metadata") count += Number(writeCacheAsset(outputDir, index, appIsrCacheKey(cachePathname, "route", manifest.buildId), "route", path.join(prerenderDir, getAppRouteOutputPath(pathname)), route));
 	}
 	if (count > 0) fs.writeFileSync(path.join(outputDir, "index.json"), JSON.stringify(index));

package/dist/cache/static-assets-adapter.d.ts

@@ -6,7 +6,7 @@ export type StaticAssetsAdapterOptions = {
 /**
  * Read-only page cache backed by Workers Static Assets.
  *
- * Locally prerendered App Router HTML, RSC, and metadata responses are copied
+ * Locally prerendered Pages HTML/data and App HTML, RSC, and metadata are copied
  * into `dist/client` after the build. Runtime cache writes and invalidations are
  * intentionally no-ops; a new deployment replaces the cache contents.
  */

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

@@ -4,7 +4,7 @@ import { fileURLToPath } from "node:url";
 /**
 * Read-only page cache backed by Workers Static Assets.
 *
-* Locally prerendered App Router HTML, RSC, and metadata responses are copied
+* Locally prerendered Pages HTML/data and App HTML, RSC, and metadata are copied
 * into `dist/client` after the build. Runtime cache writes and invalidations are
 * intentionally no-ops; a new deployment replaces the cache contents.
 */

package/dist/cache/static-assets-adapter.runtime.d.ts

@@ -6,7 +6,8 @@ type AssetFetcher = {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 };
 export declare class StaticAssetsCacheAdapter implements CdnCacheAdapter {
-  private readonly assets;
+  readonly assets: AssetFetcher;
+  readonly hasPrerenderedPages = true;
   readonly ownsBackgroundRevalidation = false;
   private indexPromise;
   constructor(assets: AssetFetcher);

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

@@ -6,10 +6,11 @@ async function cacheAssetId(key) {
 	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 function isMetadata(value) {
-	return value !== null && typeof value === "object" && "kind" in value && (value.kind === "html" || value.kind === "rsc" || value.kind === "route") && "lastModified" in value && typeof value.lastModified === "number";
+	return value !== null && typeof value === "object" && "kind" in value && (value.kind === "html" || value.kind === "rsc" || value.kind === "route" || value.kind === "pages" || value.kind === "redirect" || value.kind === "not-found") && "lastModified" in value && typeof value.lastModified === "number";
 }
 var StaticAssetsCacheAdapter = class {
 	assets;
+	hasPrerenderedPages = true;
 	ownsBackgroundRevalidation = false;
 	indexPromise;
 	constructor(assets) {
@@ -22,11 +23,27 @@ var StaticAssetsCacheAdapter = class {
 		const id = await cacheAssetId(key);
 		const metadata = (await this.loadIndex())?.[id];
 		if (!isMetadata(metadata)) return null;
-		const extension = metadata.kind === "html" ? "html" : metadata.kind === "rsc" ? "rsc" : "route";
+		const extension = metadata.kind;
 		const bodyResponse = await this.assets.fetch(`https://vinext.invalid${STATIC_ASSET_CACHE_PATH}/${id}.${extension}`);
 		if (!bodyResponse.ok) return null;
 		let value;
-		if (metadata.kind === "html") value = {
+		if (metadata.kind === "not-found") {
+			await bodyResponse.body?.cancel();
+			value = null;
+		} else if (metadata.kind === "redirect") value = {
+			kind: "REDIRECT",
+			props: await bodyResponse.json()
+		};
+		else if (metadata.kind === "pages") {
+			const { html, pageData } = await bodyResponse.json();
+			value = {
+				kind: "PAGES",
+				html,
+				pageData,
+				headers: metadata.headers,
+				status: metadata.status
+			};
+		} else if (metadata.kind === "html") value = {
 			kind: "APP_PAGE",
 			html: await bodyResponse.text(),
 			rscData: void 0,
@@ -39,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/static-assets-adapter.shared.d.ts

@@ -2,7 +2,7 @@ import { CacheControlMetadata } from "vinext/shims/cache-handler";
 //#region src/cache/static-assets-adapter.shared.d.ts
 export declare const STATIC_ASSET_CACHE_PATH = "/_vinext/static-cache";
 export type StaticAssetCacheMetadata = {
-  kind: "html" | "rsc" | "route";
+  kind: "html" | "rsc" | "route" | "pages" | "redirect" | "not-found";
   lastModified: number;
   cacheControl?: CacheControlMetadata;
   headers?: Record<string, string | string[]>;

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

@@ -12,15 +12,15 @@ export type CdnAdapterOptions = {
  * Unlike the data adapter (which stores cache entries in a durable store and
  * serves HIT/STALE itself), this adapter delegates serving to Workers Cache on
  * a named Worker entrypoint. The default entrypoint always runs middleware and
- * request-time routing before dispatching to cached or uncached response-stage
- * entrypoints.
+ * request-time routing, then renders bypass requests inline or dispatches shared
+ * requests to the cached response-stage entrypoint.
  *
  * The deployment configuration enables Workers Cache only for that response-stage
  * export, so cache hits do not start the application stage. Legacy Cloudflare
  * builds receive this policy in their generated Wrangler config. Cloudflare Vite
  * plugin v2 builds declare the same entrypoint policy in `cloudflare.config.ts`.
- * The uncached response entrypoint keeps bypass and probe renders out of the
- * gateway without enabling Workers Cache for them.
+ * Deployment readiness probes still use the uncached response entrypoint to
+ * verify that named response entrypoints are available.
  *
  * The adapter adds a transport-only URL digest so distinct response-stage
  * identities cannot collide. Workers Cache owns this key independently of

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

@@ -10,15 +10,15 @@ const CLOUDFLARE_WORKER_ENTRY_ID = "virtual:cloudflare/worker-entry";
 * Unlike the data adapter (which stores cache entries in a durable store and
 * serves HIT/STALE itself), this adapter delegates serving to Workers Cache on
 * a named Worker entrypoint. The default entrypoint always runs middleware and
-* request-time routing before dispatching to cached or uncached response-stage
-* entrypoints.
+* request-time routing, then renders bypass requests inline or dispatches shared
+* requests to the cached response-stage entrypoint.
 *
 * The deployment configuration enables Workers Cache only for that response-stage
 * export, so cache hits do not start the application stage. Legacy Cloudflare
 * builds receive this policy in their generated Wrangler config. Cloudflare Vite
 * plugin v2 builds declare the same entrypoint policy in `cloudflare.config.ts`.
-* The uncached response entrypoint keeps bypass and probe renders out of the
-* gateway without enabling Workers Cache for them.
+* Deployment readiness probes still use the uncached response entrypoint to
+* verify that named response entrypoints are available.
 *
 * The adapter adds a transport-only URL digest so distinct response-stage
 * identities cannot collide. Workers Cache owns this key independently of

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

@@ -373,7 +373,7 @@ const CDN_CACHE_POLICY_HEADERS = [
 	"CDN-Cache-Control",
 	"Cache-Control"
 ];
-function splitCacheControlDirectives(value) {
+function splitCacheControlDirectives$1(value) {
 	const directives = [];
 	let start = 0;
 	let quoted = false;
@@ -392,7 +392,7 @@ function splitCacheControlDirectives(value) {
 	return directives;
 }
 function hasFieldQualifiedSetCookie(value) {
-	return splitCacheControlDirectives(value).some((directive) => {
+	return splitCacheControlDirectives$1(value).some((directive) => {
 		const separator = directive.indexOf("=");
 		if (separator === -1) return false;
 		const name = directive.slice(0, separator).trim().toLowerCase();
@@ -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.0",
+  "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.0"
+    "@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.0"
+    "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.0"
+    "vinext": "^1.1.0"
   },
   "peerDependenciesMeta": {
     "@cloudflare/vite-plugin": {