@vinext/cloudflare 1.0.0 → 1.0.1

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.js

@@ -1,6 +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 { isNonCacheableCacheControl } from "vinext/shims/cdn-cache";
+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,11 +19,9 @@ 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
@@ -54,13 +52,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 +97,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 +117,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,12 +197,12 @@ 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

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

@@ -19,7 +19,7 @@ export declare class VinextCachedResponse extends WorkerEntrypoint<unknown, unkn
   fetch(request: Request): Promise<Response>;
   purge(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,6 +1,6 @@
 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 { isNonCacheableCacheControl } from "vinext/shims/cdn-cache";
+import { SHARED_RESPONSE_STAGE_HEADER, finalizeGatewayResponse } from "./browser-cache-policy.js";
+import { VINEXT_PRERENDER_READINESS_PATH, VINEXT_RSC_VARY_HEADER } from "vinext/internal/server/headers";
 import { WorkerEntrypoint } from "cloudflare:workers";
 import "vinext/internal/server/cloudflare-workers-tracing";
 import { loadVinextRequestStage } from "vinext/server/request-stage";
@@ -13,8 +13,6 @@ 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 RESPONSE_STAGE_WIRE_CACHE = {
 	bypass: "vinext-cloudflare-v1:bypass",
 	shared: "vinext-cloudflare-v1:shared"
@@ -209,33 +207,6 @@ 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));
@@ -320,7 +291,7 @@ var VinextCachedResponse = class extends WorkerEntrypoint {
 		return cache.purge(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));
@@ -336,7 +307,7 @@ 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 sharedResponses = /* @__PURE__ */ new Map();
 	const stageContext = withResponseStagePurge(withWorkerHostRuntime(context, env));
 	const dispatchResponseStage = async (stageRequest, props, options) => {
 		const expectedResponseStageBuildIdentity = getVinextCdnBuildIdentity();
@@ -349,6 +320,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 +332,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.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) {

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,3 +1,4 @@
+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_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";
@@ -153,14 +154,15 @@ function withoutRequestScopedHeaders(response, responseStageProps) {
 }
 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 || response.status === 404) && 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 || response.status === 404 && (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 +172,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 +195,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", "private, max-age=0, must-revalidate");
 	return traceCachedResponseStart(new Response(response.body, {
 		headers,
 		status: response.status,
@@ -260,7 +262,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(() => {});
@@ -315,7 +317,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/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,10 +28,10 @@ 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 metadata = {
 		kind,
@@ -31,11 +41,13 @@ function writeCacheAsset(outputDir, index, key, kind, sourcePath, route) {
 		...kind !== "rsc" && 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 +68,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,

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/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();

package/package.json

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