@vinext/cloudflare 1.0.0-beta.7 → 1.0.0-beta.8

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

@@ -28,6 +28,10 @@ const DEFAULT_BINDING = "VINEXT_KV_CACHE";
 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. */
+const KV_BULK_GET_LIMIT = 100;
 /** Matches a valid base64 string (standard alphabet with optional padding). */
 const BASE64_RE = /^[A-Za-z0-9+/]*={0,2}$/;
 /**
@@ -98,14 +102,20 @@ var KVCacheHandler = class {
 	ttlSeconds;
 	/** Local in-memory cache for tag invalidation timestamps. Avoids redundant KV reads. */
 	_tagCache = /* @__PURE__ */ new Map();
+	/** Monotonic ordering for concurrent tag-cache fills and local invalidations. */
+	_tagCacheOrder = 0;
 	/** TTL (ms) for local tag cache entries. After this, re-fetch from KV. */
 	_tagCacheTtl;
+	/** Read options for entry keys only. `undefined` keeps the KV default cacheTtl. */
+	_entryReadOptions;
 	constructor(kvNamespace, options) {
 		this.kv = kvNamespace;
 		this.keySpace = createKvKeySpace(options?.appPrefix);
 		this.ctx = options?.ctx;
-		this.ttlSeconds = options?.ttlSeconds ?? 720 * 3600;
+		this.ttlSeconds = options?.ttlSeconds ?? 2592e3;
 		this._tagCacheTtl = options?.tagCacheTtlMs ?? 5e3;
+		const entryCacheTtl = options?.entryCacheTtlSeconds;
+		this._entryReadOptions = typeof entryCacheTtl === "number" && Number.isFinite(entryCacheTtl) ? { cacheTtl: Math.max(MIN_KV_CACHE_TTL_SECONDS, Math.floor(entryCacheTtl)) } : void 0;
 	}
 	_entryKey(key) {
 		return this.keySpace.entryKey(key);
@@ -115,37 +125,64 @@ var KVCacheHandler = class {
 	}
 	async get(key, _ctx) {
 		const kvKey = this._entryKey(key);
-		const raw = await this.kv.get(kvKey);
+		const softTags = validUniqueTags(readStringArrayField(_ctx, "softTags"));
+		const entryRead = this._entryReadOptions ? this.kv.get(kvKey, this._entryReadOptions) : this.kv.get(kvKey);
+		let softTagCache = this._tagCache;
+		const softTagPrime = this._primeTagCache(softTags);
+		if (softTags.length > 0) {
+			const backgroundPrime = softTagPrime.catch(() => {});
+			const ctx = getRequestExecutionContext() ?? this.ctx;
+			if (ctx) ctx.waitUntil(backgroundPrime);
+		}
+		const raw = await entryRead;
 		if (!raw) return null;
 		let parsed;
 		try {
 			parsed = JSON.parse(raw);
 		} catch {
-			this._deleteInBackground(kvKey);
+			this._deleteEntryReadInBackground(kvKey);
 			return null;
 		}
 		const entry = validateCacheEntry(parsed);
 		if (!entry) {
 			console.error("[vinext] Invalid cache entry shape for key:", key);
-			this._deleteInBackground(kvKey);
+			this._deleteEntryReadInBackground(kvKey);
 			return null;
 		}
 		let restoredValue = null;
 		if (entry.value) {
 			restoredValue = restoreArrayBuffers(entry.value);
 			if (!restoredValue) {
-				this._deleteInBackground(kvKey);
+				this._deleteEntryReadInBackground(kvKey);
 				return null;
 			}
 		}
-		if (await this._hasRevalidatedTag(validUniqueTags(entry.tags), entry.lastModified)) {
-			this._deleteInBackground(kvKey);
+		const entryTags = validUniqueTags(entry.tags);
+		if (this._hasRevalidatedTag(entryTags, entry.lastModified, true)) {
+			this._deleteEntryReadInBackground(kvKey);
 			return null;
 		}
-		const softTags = validUniqueTags(readStringArrayField(_ctx, "softTags"));
-		if (await this._hasRevalidatedTag(softTags, entry.lastModified)) return null;
+		await softTagPrime;
+		while (softTagCache !== this._tagCache) {
+			softTagCache = this._tagCache;
+			await this._primeTagCache(softTags);
+		}
+		let invalidated = this._hasRevalidatedTag(entryTags, entry.lastModified, true);
+		if (!invalidated) {
+			await this._primeTagCache(entryTags);
+			while (softTagCache !== this._tagCache) {
+				softTagCache = this._tagCache;
+				await this._primeTagCache([.../* @__PURE__ */ new Set([...softTags, ...entryTags])]);
+			}
+			invalidated = this._hasRevalidatedTag(entryTags, entry.lastModified);
+		}
+		if (invalidated) {
+			this._deleteEntryReadInBackground(kvKey);
+			return null;
+		}
+		if (this._hasRevalidatedTag(softTags, entry.lastModified)) return null;
 		if (entry.expireAt !== void 0 && entry.expireAt !== null && Date.now() > entry.expireAt) {
-			this._deleteInBackground(kvKey);
+			this._deleteEntryReadInBackground(kvKey);
 			return null;
 		}
 		const now = Date.now();
@@ -164,37 +201,63 @@ var KVCacheHandler = class {
 		};
 	}
 	/**
-	* Check tag invalidation markers for stored tags or read-time soft tags.
-	* Uses a local in-memory cache to avoid redundant KV reads for recently-seen tags.
+	* Load the invalidation markers these tags still need into the local cache.
+	* Tags a recent read already cached cost nothing, so the entry-tag batch only
+	* pays for what the soft-tag batch did not already fetch.
 	*/
-	async _hasRevalidatedTag(tags, lastModified) {
-		if (tags.length === 0) return false;
+	async _primeTagCache(tags) {
+		if (tags.length === 0) return;
+		const tagCache = this._tagCache;
 		const now = Date.now();
-		const uncachedTags = [];
+		const missing = tags.filter((tag) => {
+			const cached = tagCache.get(tag);
+			if (cached && now - cached.fetchedAt < this._tagCacheTtl) return false;
+			if (cached) tagCache.delete(tag);
+			return true;
+		});
+		if (missing.length === 0) return;
+		const order = ++this._tagCacheOrder;
+		const markers = await this._readTagMarkers(missing.map((tag) => this._tagKey(tag)));
+		for (const tag of missing) {
+			const current = tagCache.get(tag);
+			if (current && current.order >= order) continue;
+			const marker = markers.get(this._tagKey(tag));
+			tagCache.set(tag, {
+				timestamp: marker ? Number(marker) : 0,
+				fetchedAt: now,
+				order
+			});
+		}
+	}
+	/**
+	* Read every marker key, one round trip per 100-key chunk.
+	*
+	* Markers never take the entry `cacheTtl`: `revalidateTag()` writes them, so
+	* a longer colo cache would hide a publish from that colo for its span. They
+	* keep KV's own default cacheTtl of 60 s.
+	*/
+	async _readTagMarkers(keys) {
+		if (keys.length === 1) return /* @__PURE__ */ new Map([[keys[0], await this.kv.get(keys[0])]]);
+		const chunks = [];
+		for (let i = 0; i < keys.length; i += KV_BULK_GET_LIMIT) chunks.push(keys.slice(i, i + KV_BULK_GET_LIMIT));
+		const results = await Promise.all(chunks.map((chunk) => this.kv.get(chunk)));
+		const markers = /* @__PURE__ */ new Map();
+		for (const result of results) for (const [key, value] of result) markers.set(key, value);
+		return markers;
+	}
+	/**
+	* Report whether any tag has an invalidation marker at or after `lastModified`.
+	* Call `_primeTagCache` for the same tags first — a tag with no cache entry
+	* counts as never invalidated. Pass `requireFresh` to call it before a prime,
+	* so an entry past `tagCacheTtlMs` does not answer for a tag it never re-read.
+	*/
+	_hasRevalidatedTag(tags, lastModified, requireFresh = false) {
+		const now = requireFresh ? Date.now() : 0;
 		for (const tag of tags) {
 			const cached = this._tagCache.get(tag);
-			if (cached && now - cached.fetchedAt < this._tagCacheTtl) {
-				if (Number.isNaN(cached.timestamp) || cached.timestamp >= lastModified) return true;
-			} else {
-				if (cached) this._tagCache.delete(tag);
-				uncachedTags.push(tag);
-			}
-		}
-		if (uncachedTags.length > 0) {
-			const tagResults = await Promise.all(uncachedTags.map((tag) => this.kv.get(this._tagKey(tag))));
-			for (let i = 0; i < uncachedTags.length; i++) {
-				const tagTime = tagResults[i];
-				const tagTimestamp = tagTime ? Number(tagTime) : 0;
-				this._tagCache.set(uncachedTags[i], {
-					timestamp: tagTimestamp,
-					fetchedAt: now
-				});
-			}
-			for (const tag of uncachedTags) {
-				const cached = this._tagCache.get(tag);
-				if (!cached || cached.timestamp === 0) continue;
-				if (Number.isNaN(cached.timestamp) || cached.timestamp >= lastModified) return true;
-			}
+			if (!cached || cached.timestamp === 0) continue;
+			if (requireFresh && now - cached.fetchedAt >= this._tagCacheTtl) continue;
+			if (Number.isNaN(cached.timestamp) || cached.timestamp >= lastModified) return true;
 		}
 		return false;
 	}
@@ -243,10 +306,12 @@ var KVCacheHandler = class {
 		const tagList = Array.isArray(tags) ? tags : [tags];
 		const now = Date.now();
 		const validTags = tagList.filter((t) => validateTag(t) !== null);
-		await Promise.all(validTags.map((tag) => this.kv.put(this._tagKey(tag), String(now), { expirationTtl: 720 * 3600 })));
+		await Promise.all(validTags.map((tag) => this.kv.put(this._tagKey(tag), String(now), { expirationTtl: 2592e3 })));
+		const order = ++this._tagCacheOrder;
 		for (const tag of validTags) this._tagCache.set(tag, {
 			timestamp: now,
-			fetchedAt: now
+			fetchedAt: now,
+			order
 		});
 	}
 	/**
@@ -302,7 +367,15 @@ var KVCacheHandler = class {
 	* fresh KVCacheHandler per request or invoke this method explicitly.
 	*/
 	resetRequestCache() {
-		this._tagCache.clear();
+		this._tagCache = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Clean up a bad entry only when this read cannot be an explicitly cached
+	* older version of the shared KV value. KV has no conditional delete, so a
+	* cached read must remain a non-destructive miss.
+	*/
+	_deleteEntryReadInBackground(kvKey) {
+		if (!this._entryReadOptions) this._deleteInBackground(kvKey);
 	}
 	/**
 	* Fire a KV delete in the background.
@@ -453,7 +526,8 @@ const createKvDataCacheAdapter = ({ env, options }) => {
 	return new KVCacheHandler(namespace, {
 		appPrefix: options?.appPrefix,
 		ttlSeconds: options?.ttlSeconds,
-		tagCacheTtlMs: options?.tagCacheTtlMs
+		tagCacheTtlMs: options?.tagCacheTtlMs,
+		entryCacheTtlSeconds: options?.entryCacheTtlSeconds
 	});
 };
 //#endregion

package/dist/cache/kv-key.d.ts

@@ -1,7 +1,7 @@
 //#region src/cache/kv-key.d.ts
 /** Key prefix for cache entries. */
-declare const ENTRY_PREFIX = "cache:";
-type KvKeySpace = {
+export declare const ENTRY_PREFIX = "cache:";
+export type KvKeySpace = {
   /** Prefix shared by every cache entry, including entries with hashed logical keys. */
   entryPrefix: string;
   entryKey(logicalKey: string): string;
@@ -11,6 +11,5 @@ type KvKeySpace = {
  * Create the deterministic key namespace shared by runtime cache operations
  * and deploy-time prerender population.
  */
-declare function createKvKeySpace(appPrefix: string | undefined): KvKeySpace;
-//#endregion
-export { ENTRY_PREFIX, KvKeySpace, createKvKeySpace };
+export declare function createKvKeySpace(appPrefix: string | undefined): KvKeySpace;
+//#endregion

package/dist/cache/response-store-adapter.d.ts

@@ -0,0 +1,37 @@
+//#region src/cache/response-store-adapter.d.ts
+export type ResponseStoreAdapterOptions = {
+  mode?: "self-contained" | "service-binding";
+};
+/**
+ * Use Workers Response Store for both vinext response-stage and data caching.
+ * Service-binding mode keeps storage in a separate cache Worker. Self-contained
+ * mode keeps the same API and loopback in the application Worker.
+ */
+export declare function responseStoreAdapter(options?: ResponseStoreAdapterOptions): {
+  cdn: {
+    adapter: string;
+    output: {
+      entry: string;
+      matchesBuild({ plugins }: {
+        plugins: readonly {
+          name?: string;
+        }[];
+      }): boolean;
+      transformHostEntry({ code, id }: {
+        code: string;
+        id: string;
+      }): string | null;
+      type: "multi-stage";
+    };
+    capabilities: {
+      buildIdentity: "response-header";
+      isResponsePolicyHeader: (name: string) => boolean;
+      requestRouting: "uncached-stage";
+      warmup: "response-store";
+    };
+  };
+  data: {
+    adapter: string;
+  };
+};
+//#endregion

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

@@ -0,0 +1,39 @@
+import { fileURLToPath } from "node:url";
+//#region src/cache/response-store-adapter.ts
+const CLOUDFLARE_WORKER_ENTRY_ID = "virtual:cloudflare/worker-entry";
+/**
+* Use Workers Response Store for both vinext response-stage and data caching.
+* Service-binding mode keeps storage in a separate cache Worker. Self-contained
+* mode keeps the same API and loopback in the application Worker.
+*/
+function responseStoreAdapter(options = {}) {
+	const mode = options.mode ?? "service-binding";
+	if (mode !== "service-binding" && mode !== "self-contained") throw new Error(`Unknown Workers Response Store mode: ${String(mode)}`);
+	const workerEntry = fileURLToPath(import.meta.resolve(mode === "self-contained" ? "./response-store-adapter.self-contained.worker.js" : "./response-store-adapter.service-binding.worker.js"));
+	const entrypoints = mode === "self-contained" ? "CacheMetadata, ResponseStoreBinding, ResponseStoreRevalidator" : "ResponseStoreClient, ResponseStoreRevalidator";
+	return {
+		cdn: {
+			adapter: fileURLToPath(import.meta.resolve("./response-store-cdn.runtime.js")),
+			output: {
+				entry: workerEntry,
+				matchesBuild({ plugins }) {
+					return plugins.some(({ name }) => name === "vite-plugin-cloudflare" || name?.startsWith("vite-plugin-cloudflare:"));
+				},
+				transformHostEntry({ code, id }) {
+					if ((id.charCodeAt(0) === 0 ? id.slice(1) : id) !== CLOUDFLARE_WORKER_ENTRY_ID) return null;
+					return `${code}\nexport { ${entrypoints} } from ${JSON.stringify(workerEntry)};\n`;
+				},
+				type: "multi-stage"
+			},
+			capabilities: {
+				buildIdentity: "response-header",
+				isResponsePolicyHeader: (name) => name.toLowerCase() === "cdn-cache-control" || name.toLowerCase() === "cloudflare-cdn-cache-control",
+				requestRouting: "uncached-stage",
+				warmup: "response-store"
+			}
+		},
+		data: { adapter: fileURLToPath(import.meta.resolve("./response-store-data.runtime.js")) }
+	};
+}
+//#endregion
+export { responseStoreAdapter };

package/dist/cache/response-store-adapter.self-contained.worker.d.ts

@@ -0,0 +1,17 @@
+import { VinextResponseStoreEnv } from "./response-store-adapter.worker.js";
+import { ResponseStoreRevalidatorEntrypoint, WorkersResponseStoreEnv } from "@cloudflare/workers-response-store";
+import { CacheMetadata as CacheMetadata$1, ResponseStoreBinding as ResponseStoreBinding$1 } from "@cloudflare/workers-response-store/service";
+//#region src/cache/response-store-adapter.self-contained.worker.d.ts
+export declare const CacheMetadata: typeof CacheMetadata$1;
+export declare const ResponseStoreBinding: typeof ResponseStoreBinding$1;
+export declare const ResponseStoreRevalidator: ResponseStoreRevalidatorEntrypoint<WorkersResponseStoreEnv>;
+declare const _default: {
+  fetch(request: Request, env: VinextResponseStoreEnv, ctx: {
+    exports?: Record<string, unknown>;
+    passThroughOnException(): void;
+    props?: unknown;
+    waitUntil(promise: Promise<unknown>): void;
+  }): Promise<Response>;
+};
+//#endregion
+export { _default as default };

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

@@ -0,0 +1,10 @@
+import { createVinextResponseStoreHandler, createVinextResponseStoreOptions } from "./response-store-adapter.worker.js";
+import { createWorkersResponseStore } from "@cloudflare/workers-response-store";
+//#region src/cache/response-store-adapter.self-contained.worker.ts
+const responseStore = createWorkersResponseStore(createVinextResponseStoreOptions());
+const CacheMetadata = responseStore.entrypoints.CacheMetadata;
+const ResponseStoreBinding = responseStore.entrypoints.ResponseStoreBinding;
+const ResponseStoreRevalidator = responseStore.entrypoints.ResponseStoreRevalidator;
+var response_store_adapter_self_contained_worker_default = createVinextResponseStoreHandler(responseStore);
+//#endregion
+export { CacheMetadata, ResponseStoreBinding, ResponseStoreRevalidator, response_store_adapter_self_contained_worker_default as default };

package/dist/cache/response-store-adapter.service-binding.worker.d.ts

@@ -0,0 +1,15 @@
+import { VinextResponseStoreEnv } from "./response-store-adapter.worker.js";
+import { ResponseStoreClientEntrypoint, ResponseStoreRevalidatorEntrypoint, WorkersResponseStoreClientEnv } from "@cloudflare/workers-response-store";
+//#region src/cache/response-store-adapter.service-binding.worker.d.ts
+export declare const ResponseStoreClient: ResponseStoreClientEntrypoint;
+export declare const ResponseStoreRevalidator: ResponseStoreRevalidatorEntrypoint<WorkersResponseStoreClientEnv>;
+declare const _default: {
+  fetch(request: Request, env: VinextResponseStoreEnv, ctx: {
+    exports?: Record<string, unknown>;
+    passThroughOnException(): void;
+    props?: unknown;
+    waitUntil(promise: Promise<unknown>): void;
+  }): Promise<Response>;
+};
+//#endregion
+export { _default as default };

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

@@ -0,0 +1,9 @@
+import { createVinextResponseStoreHandler, createVinextResponseStoreOptions } from "./response-store-adapter.worker.js";
+import { createWorkersResponseStoreClient } from "@cloudflare/workers-response-store";
+//#region src/cache/response-store-adapter.service-binding.worker.ts
+const responseStore = createWorkersResponseStoreClient(createVinextResponseStoreOptions());
+const ResponseStoreClient = responseStore.entrypoints.ResponseStoreClient;
+const ResponseStoreRevalidator = responseStore.entrypoints.ResponseStoreRevalidator;
+var response_store_adapter_service_binding_worker_default = createVinextResponseStoreHandler(responseStore);
+//#endregion
+export { ResponseStoreClient, ResponseStoreRevalidator, response_store_adapter_service_binding_worker_default as default };

package/dist/cache/response-store-adapter.worker.d.ts

@@ -0,0 +1,14 @@
+import { WorkersResponseStore, WorkersResponseStoreClientEnv, WorkersResponseStoreEnv, WorkersResponseStoreOptions } from "@cloudflare/workers-response-store";
+//#region src/cache/response-store-adapter.worker.d.ts
+type WorkerExecutionContext = {
+  exports?: Record<string, unknown>;
+  passThroughOnException(): void;
+  props?: unknown;
+  waitUntil(promise: Promise<unknown>): void;
+};
+export type VinextResponseStoreEnv = WorkersResponseStoreClientEnv | WorkersResponseStoreEnv;
+export declare function createVinextResponseStoreOptions<Env extends VinextResponseStoreEnv>(): WorkersResponseStoreOptions<Env>;
+export declare function createVinextResponseStoreHandler(store: WorkersResponseStore): {
+  fetch(request: Request, env: VinextResponseStoreEnv, ctx: WorkerExecutionContext): Promise<Response>;
+};
+//#endregion

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

@@ -0,0 +1,254 @@
+import { captureResponseStoreDataRegeneration, runWithResponseStoreInvocation, setResponseStore } from "./response-store-data.runtime.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, 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";
+import { loadVinextResponseStage } from "vinext/server/response-stage";
+//#region src/cache/response-store-adapter.worker.ts
+const ROUTE_REVALIDATOR_ID = "vinext:response";
+const RESPONSE_STORE_KEY_PARAM = "__vinext_response_store";
+const AGE_BASIS_HEADER = "X-Workers-Response-Store-Age-Basis";
+const WARMUP_USER_AGENT = "vinext-cloudflare-cdn-warm";
+const REPLAY_REQUEST_HEADERS = VINEXT_RSC_VARY_HEADER.split(",").map((name) => name.trim().toLowerCase());
+function stageContext(ctx, env) {
+	const assets = Reflect.get(env, "ASSETS");
+	return Object.assign(Object.create(Object.getPrototypeOf(ctx)), ctx, {
+		...assets && typeof assets === "object" && typeof Reflect.get(assets, "fetch") === "function" ? { assets } : {},
+		...ctx.exports ? { exports: ctx.exports } : {},
+		hostRuntime: "worker",
+		passThroughOnException: () => ctx.passThroughOnException(),
+		...ctx.props === void 0 ? {} : { props: ctx.props },
+		waitUntil: (promise) => ctx.waitUntil(promise)
+	});
+}
+function safeProps(props) {
+	const copy = JSON.parse(JSON.stringify(props));
+	if (copy && typeof copy === "object") {
+		if ("draftModeCookie" in copy) copy.draftModeCookie = null;
+		if ("middlewareCookieOverlay" in copy) copy.middlewareCookieOverlay = null;
+	}
+	return copy;
+}
+function replayHeaders(request) {
+	return REPLAY_REQUEST_HEADERS.flatMap((name) => {
+		const value = request.headers.get(name);
+		return value === null ? [] : [[name, value]];
+	});
+}
+function isReplayableInvocation(request, props) {
+	const method = request.method.toUpperCase();
+	if (method !== "GET" && method !== "HEAD") return false;
+	if (request.headers.has("authorization") || request.headers.has("cookie")) return false;
+	return !(props && typeof props === "object" && ["draftModeCookie", "middlewareCookieOverlay"].some((name) => name in props && Reflect.get(props, name) !== null));
+}
+function serializeInvocation(request, props) {
+	return JSON.stringify({
+		props: safeProps(props),
+		request: {
+			headers: replayHeaders(request),
+			method: request.method,
+			url: request.url
+		}
+	});
+}
+function parseInvocation(value) {
+	if (typeof value !== "string") throw new TypeError("Invalid vinext response-store invocation");
+	const invocation = JSON.parse(value);
+	if (!invocation || typeof invocation !== "object" || !invocation.request || typeof invocation.request.url !== "string" || typeof invocation.request.method !== "string" || !Array.isArray(invocation.request.headers)) throw new TypeError("Invalid vinext response-store invocation");
+	return invocation;
+}
+function restoreRequest(invocation) {
+	return new Request(invocation.request.url, {
+		headers: invocation.request.headers,
+		method: invocation.request.method
+	});
+}
+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));
+}
+async function invokeResponseStage(request, props, env, ctx, cache, capture) {
+	const context = stageContext(ctx, env);
+	const dispatchRequestStage = (request) => invokeRequestStage(request, env, ctx);
+	const { handleResponseStage } = await loadVinextResponseStage();
+	const serialized = serializeInvocation(request, props);
+	return runWithResponseStoreInvocation(serialized, isReplayableInvocation(request, props), () => handleResponseStage(request, env, context, props, dispatchRequestStage, { cache }), capture);
+}
+function createVinextResponseStoreOptions() {
+	return { 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");
+			if (!isCacheable(response)) {
+				await response.body?.cancel().catch(() => {});
+				throw new Error("Vinext response-stage regeneration was not cacheable");
+			}
+			return response;
+		}
+		if (input.id === "vinext:cache-function" && typeof input.args[0] === "string" && typeof input.args[1] === "string") {
+			const invocation = JSON.parse(input.args[1]);
+			if (!invocation || typeof invocation.referenceId !== "string" || typeof invocation.encryptedArgs !== "string" || !invocation.rootParams || typeof invocation.rootParams !== "object" || !Array.isArray(invocation.softTags)) throw new TypeError("Invalid vinext cache function invocation");
+			return captureResponseStoreDataRegeneration(input.args[0], async () => {
+				const responseStage = await loadVinextResponseStage();
+				if (!responseStage.invokeCacheFunction) throw new Error("The vinext response stage cannot invoke cache functions");
+				await responseStage.invokeCacheFunction(invocation, env, stageContext(ctx, env), (request) => invokeRequestStage(request, env, ctx));
+			});
+		}
+		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());
+			});
+		}
+		throw new Error(`Unknown vinext response-store revalidator ${input.id}`);
+	} };
+}
+async function cacheRequest(request, props) {
+	const identity = JSON.stringify([
+		request.method,
+		request.url,
+		safeProps(props),
+		replayHeaders(request)
+	]);
+	const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(identity)));
+	const url = new URL(request.url);
+	url.searchParams.set(RESPONSE_STORE_KEY_PARAM, [...digest].map((byte) => byte.toString(16).padStart(2, "0")).join(""));
+	return new Request(url, { method: "GET" });
+}
+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);
+}
+function isResponseStoreMiss(response) {
+	return response.status === 404 && response.headers.get("X-Workers-Response-Store") === "MISS";
+}
+function publicResponse(response, cacheStatus) {
+	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) ?? "");
+	if (cacheStatus === "HIT" && ageBasis) {
+		const elapsed = (BigInt(Date.now()) - BigInt(ageBasis[1])) / 1000n;
+		headers.set("Age", String(BigInt(ageBasis[2]) + (elapsed > 0n ? elapsed : 0n)));
+	}
+	for (const name of [
+		"Cache-Tag",
+		"CDN-Cache-Control",
+		"CF-Cache-Status",
+		"Cloudflare-CDN-Cache-Control",
+		"X-Workers-Response-Store",
+		AGE_BASIS_HEADER,
+		"X-Workers-Response-Store-Binding-Invocation",
+		"X-Workers-Response-Store-Revision"
+	]) headers.delete(name);
+	if (publicCacheStatus) {
+		headers.set("X-Nextjs-Cache", publicCacheStatus);
+		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");
+	return new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
+let responseStore;
+function createVinextResponseStoreHandler(store) {
+	responseStore = store;
+	setResponseStore(store);
+	return handler;
+}
+const handler = { async fetch(request, env, ctx) {
+	const context = stageContext(ctx, env);
+	const dispatchResponseStage = async (stageRequest, props, options) => {
+		const invocation = serializeInvocation(stageRequest, props);
+		if (options.cache === "bypass" || stageRequest.method !== "GET" && stageRequest.method !== "HEAD") return publicResponse(await invokeResponseStage(stageRequest, props, env, ctx, "bypass"), "BYPASS");
+		const isWarmup = request.headers.get("user-agent") === WARMUP_USER_AGENT;
+		const rscSeed = isWarmup && props !== null && typeof props === "object" && Reflect.get(props, "kind") === "app-page" && Reflect.get(props, "isRscRequest") === false && Reflect.get(props, "matchKind") === "request" && Reflect.get(props, "interceptionContext") === null && Reflect.get(props, "interceptionId") === null && Reflect.get(props, "mountedSlotsHeader") === null ? {
+			props: {
+				...props,
+				isRscRequest: true,
+				renderMode: "navigation"
+			},
+			request: new Request(new URL(createCanonicalRscRequestUrl(stageRequest.url), stageRequest.url), { headers: createCanonicalRscRequestHeaders() })
+		} : void 0;
+		const rscKey = rscSeed ? await cacheRequest(rscSeed.request, rscSeed.props) : void 0;
+		const key = await cacheRequest(stageRequest, props);
+		const stored = await responseStore.fetch(key);
+		if (!isResponseStoreMiss(stored)) {
+			if (!rscKey) return publicResponse(stored, "HIT");
+			const storedRsc = await responseStore.fetch(rscKey);
+			if (!isResponseStoreMiss(storedRsc)) {
+				await storedRsc.body?.cancel();
+				return publicResponse(stored, "HIT");
+			}
+			await Promise.all([stored.body?.cancel(), storedRsc.body?.cancel()]);
+		}
+		const capture = rscSeed ? { captureRscData: true } : isWarmup ? {} : { streamResponse: true };
+		const rendered = await invokeResponseStage(stageRequest, props, env, ctx, "shared", capture);
+		if (capture.admittedResponse) {
+			ctx.waitUntil(capture.admittedResponse.then(async (admitted) => {
+				if (!isCacheable(admitted)) {
+					await admitted.body?.cancel().catch(() => {});
+					return;
+				}
+				await responseStore.put(key, admitted, {
+					coalesce: true,
+					revalidator: {
+						id: ROUTE_REVALIDATOR_ID,
+						args: [invocation]
+					}
+				});
+			}).catch((error) => {
+				console.error(JSON.stringify({
+					message: "Vinext response-store admission failed",
+					error: error instanceof Error ? error.message : String(error)
+				}));
+			}));
+			return publicResponse(rendered, "MISS");
+		}
+		if (!isCacheable(rendered)) {
+			capture?.rscData?.catch(() => {});
+			return publicResponse(rendered, "BYPASS");
+		}
+		if (rscSeed && !capture?.rscData) {
+			await rendered.body?.cancel();
+			throw new Error("Vinext response-store warmup did not capture the App page RSC payload");
+		}
+		const [foreground, cacheBody] = rendered.body ? rendered.body.tee() : [null, null];
+		const cacheResponse = new Response(cacheBody, rendered);
+		await responseStore.put(key, cacheResponse, {
+			coalesce: true,
+			revalidator: {
+				id: ROUTE_REVALIDATOR_ID,
+				args: [invocation]
+			}
+		});
+		if (rscSeed && rscKey && capture?.rscData) {
+			const rscData = await capture.rscData;
+			const rscHeaders = new Headers(rendered.headers);
+			rscHeaders.delete("Content-Length");
+			rscHeaders.delete("Link");
+			rscHeaders.delete("X-Vinext-Response-Store-Replayable");
+			rscHeaders.set("Content-Type", VINEXT_RSC_CONTENT_TYPE);
+			rscHeaders.set("Vary", VINEXT_RSC_VARY_HEADER);
+			applyRscCompatibilityIdHeader(rscHeaders);
+			applyRscDeploymentIdHeader(rscHeaders);
+			const rscInvocation = serializeInvocation(rscSeed.request, rscSeed.props);
+			await responseStore.put(rscKey, new Response(rscData, {
+				headers: rscHeaders,
+				status: 200
+			}), {
+				coalesce: true,
+				revalidator: {
+					id: ROUTE_REVALIDATOR_ID,
+					args: [rscInvocation]
+				}
+			});
+		}
+		return publicResponse(new Response(foreground, rendered), "MISS");
+	};
+	const { handleRequestStage } = await loadVinextRequestStage();
+	return handleRequestStage(request, env, context, dispatchResponseStage);
+} };
+//#endregion
+export { createVinextResponseStoreHandler, createVinextResponseStoreOptions };