@vinext/cloudflare 1.0.0-beta.0 → 1.0.0-beta.10

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

@@ -0,0 +1,278 @@
+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";
+import { traceCachedResponseStart } from "vinext/internal/server/response-start-tracing";
+//#region src/cache/response-store-adapter.worker.ts
+const ROUTE_REVALIDATOR_ID = "vinext:response";
+const RESPONSE_STORE_KEY_PARAM = "__workers_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());
+const CACHE_REQUEST_VARY_HEADERS = REPLAY_REQUEST_HEADERS.map((name) => [name, "vinext-keyed"]);
+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 prepareInvocation(request, props) {
+	return {
+		props: safeProps(props),
+		request: {
+			headers: replayHeaders(request),
+			method: request.method,
+			url: request.url
+		}
+	};
+}
+function serializeInvocation(request, props) {
+	return JSON.stringify(prepareInvocation(request, props));
+}
+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, invocation) {
+	const context = stageContext(ctx, env);
+	const dispatchRequestStage = (request) => invokeRequestStage(request, env, ctx);
+	const { handleResponseStage } = await loadVinextResponseStage();
+	const storedInvocation = invocation ?? {
+		replayable: isReplayableInvocation(request, props),
+		serialized: serializeInvocation(request, props)
+	};
+	return runWithResponseStoreInvocation(storedInvocation.serialized, storedInvocation.replayable, () => handleResponseStage(request, env, context, props, dispatchRequestStage, { cache }), capture);
+}
+function createVinextResponseStoreOptions(configuration) {
+	const locationHint = configuration?.locationHint;
+	if (locationHint !== void 0 && typeof locationHint !== "string") throw new TypeError("Workers Response Store locationHint must be a string");
+	const shards = configuration?.shards;
+	if (shards !== void 0 && typeof shards !== "number") throw new TypeError("Workers Response Store shards must be a number");
+	return {
+		...locationHint === void 0 ? {} : { locationHint },
+		...shards === void 0 ? {} : { shards },
+		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(invocation) {
+	const identity = JSON.stringify([
+		invocation.request.method,
+		invocation.request.url,
+		invocation.props,
+		invocation.request.headers
+	]);
+	const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(identity)));
+	const url = new URL(invocation.request.url);
+	url.searchParams.set(RESPONSE_STORE_KEY_PARAM, `v1.${[...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`);
+	return new Request(url, {
+		headers: CACHE_REQUEST_VARY_HEADERS,
+		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, responseStageProps) {
+	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 traceCachedResponseStart(new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	}), publicCacheStatus ?? null, responseStageProps);
+}
+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) => {
+		if (options.cache === "bypass" || stageRequest.method !== "GET" && stageRequest.method !== "HEAD") return publicResponse(await invokeResponseStage(stageRequest, props, env, ctx, "bypass"), "BYPASS", props);
+		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 invocation = prepareInvocation(stageRequest, props);
+		const rscInvocation = rscSeed ? prepareInvocation(rscSeed.request, rscSeed.props) : void 0;
+		const rscKey = rscInvocation ? await cacheRequest(rscInvocation) : void 0;
+		const key = await cacheRequest(invocation);
+		const stored = await responseStore.fetch(key);
+		if (!isResponseStoreMiss(stored)) {
+			if (!rscKey) return publicResponse(stored, "HIT", props);
+			const storedRsc = await responseStore.fetch(rscKey);
+			if (!isResponseStoreMiss(storedRsc)) {
+				await storedRsc.body?.cancel();
+				return publicResponse(stored, "HIT", props);
+			}
+			await Promise.all([stored.body?.cancel(), storedRsc.body?.cancel()]);
+		}
+		const capture = rscSeed ? { captureRscData: true } : isWarmup ? {} : { streamResponse: true };
+		const serializedInvocation = JSON.stringify(invocation);
+		const rendered = await invokeResponseStage(stageRequest, props, env, ctx, "shared", capture, {
+			replayable: isReplayableInvocation(stageRequest, props),
+			serialized: serializedInvocation
+		});
+		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: [serializedInvocation]
+					}
+				});
+			}).catch((error) => {
+				console.error(JSON.stringify({
+					message: "Vinext response-store admission failed",
+					error: error instanceof Error ? error.message : String(error)
+				}));
+			}));
+			return publicResponse(rendered, "MISS", props);
+		}
+		if (!isCacheable(rendered)) {
+			capture?.rscData?.catch(() => {});
+			return publicResponse(rendered, "BYPASS", props);
+		}
+		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: [serializedInvocation]
+			}
+		});
+		if (rscSeed && rscInvocation && 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 serializedRscInvocation = JSON.stringify(rscInvocation);
+			await responseStore.put(rscKey, new Response(rscData, {
+				headers: rscHeaders,
+				status: 200
+			}), {
+				coalesce: true,
+				revalidator: {
+					id: ROUTE_REVALIDATOR_ID,
+					args: [serializedRscInvocation]
+				}
+			});
+		}
+		return publicResponse(new Response(foreground, rendered), "MISS", props);
+	};
+	const { handleRequestStage } = await loadVinextRequestStage();
+	return handleRequestStage(request, env, context, dispatchResponseStage);
+} };
+//#endregion
+export { createVinextResponseStoreHandler, createVinextResponseStoreOptions };

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

@@ -0,0 +1,5 @@
+import createCloudflareCdnCacheAdapter from "./cdn-adapter.runtime.js";
+import { CdnCacheAdapter } from "vinext/shims/cdn-cache";
+//#region src/cache/response-store-cdn.runtime.d.ts
+export default function createResponseStoreCdnCacheAdapter(context: Parameters<typeof createCloudflareCdnCacheAdapter>[0]): CdnCacheAdapter;
+//#endregion

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

@@ -0,0 +1,41 @@
+import createCloudflareCdnCacheAdapter from "./cdn-adapter.runtime.js";
+import { captureResponseStoreRscData, deferResponseStoreAdmission } from "./response-store-data.runtime.js";
+//#region src/cache/response-store-cdn.runtime.ts
+/** Response Store owns page serving and SWR; vinext only emits admitted response policy. */
+var ResponseStoreCdnCacheAdapter = class {
+	headers;
+	ownsBackgroundRevalidation = false;
+	requiresCompletedResponseAdmission = true;
+	responsePolicy;
+	constructor(headers) {
+		this.headers = headers;
+		this.responsePolicy = headers.responsePolicy;
+	}
+	get(...args) {
+		return this.headers.get(...args);
+	}
+	set(...args) {
+		return this.headers.set(...args);
+	}
+	validateRequest(request) {
+		return this.headers.validateRequest?.(request) ?? null;
+	}
+	buildResponseIdentityHeaders() {
+		return this.headers.buildResponseIdentityHeaders?.() ?? {};
+	}
+	buildResponseHeaders(input) {
+		return this.headers.buildResponseHeaders(input);
+	}
+	deferCompletedPageResponseAdmission(response, complete) {
+		return deferResponseStoreAdmission(response, complete);
+	}
+	captureAppPageRscData(rscData) {
+		captureResponseStoreRscData(rscData);
+	}
+	async revalidateTag() {}
+};
+function createResponseStoreCdnCacheAdapter(context) {
+	return new ResponseStoreCdnCacheAdapter(createCloudflareCdnCacheAdapter(context));
+}
+//#endregion
+export { createResponseStoreCdnCacheAdapter as default };

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

@@ -0,0 +1,34 @@
+import { WorkersResponseStore } from "@cloudflare/workers-response-store";
+import { CacheHandler, CacheHandlerValue, IncrementalCacheValue } from "vinext/shims/cache";
+//#region src/cache/response-store-data.runtime.d.ts
+export type ResponseStoreInvocationCapture = {
+  admittedResponse?: Promise<Response>;
+  captureRscData?: boolean;
+  rscData?: Promise<ArrayBuffer>;
+  streamResponse?: boolean;
+};
+declare const DATA_REVALIDATOR_ID = "vinext:data";
+declare const CACHE_FUNCTION_REVALIDATOR_ID = "vinext:cache-function";
+/** Connect the generated Cloudflare worker entry to the configured data adapter. */
+export declare function setResponseStore(store: WorkersResponseStore): void;
+/** Associate data-cache writes with the response-stage invocation that produced them. */
+export declare function runWithResponseStoreInvocation<T>(serialized: string, replayable: boolean, callback: () => T, capture?: ResponseStoreInvocationCapture): T;
+/** Retain the RSC side stream only when the outer response-store invocation requested it. */
+export declare function captureResponseStoreRscData(rscData: Promise<ArrayBuffer>): void;
+/** Stream the foreground body while retaining an independent admission branch. */
+export declare function deferResponseStoreAdmission(response: Response, complete: (response: Response) => Promise<Response>): Response | null;
+/** Re-render an invocation and return the exact rewritten data-cache entry. */
+export declare function captureResponseStoreDataRegeneration(key: string, callback: () => Promise<void>): Promise<Response>;
+export declare class WorkersResponseStoreCacheHandler implements CacheHandler {
+  private readonly store;
+  private readonly tagExpirations;
+  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>;
+  revalidateTag(tags: string | string[], durations?: {
+    expire?: number;
+  }): Promise<void>;
+}
+export default function createResponseStoreDataCacheAdapter(): CacheHandler;
+//#endregion
+export { CACHE_FUNCTION_REVALIDATOR_ID, DATA_REVALIDATOR_ID };

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

@@ -0,0 +1,300 @@
+import { encodeCloudflareCacheTag } from "./cdn-adapter.runtime.js";
+import { Buffer } from "node:buffer";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { cacheForRequest } from "vinext/cache";
+//#region src/cache/response-store-data.runtime.ts
+const ARRAY_BUFFER_MARKER = "$vinextArrayBuffer";
+const CACHE_MAX_AGE_SECONDS = 31536e4;
+const CACHE_MAX_AGE = `public, max-age=${CACHE_MAX_AGE_SECONDS}`;
+const DATA_ENTRY_PATH = "__vinext_data";
+const REPLAYABLE_HEADER = "X-Vinext-Response-Store-Replayable";
+const MAX_CACHE_TAG_HEADER_BYTES = 16384;
+const DATA_REVALIDATOR_ID = "vinext:data";
+const CACHE_FUNCTION_REVALIDATOR_ID = "vinext:cache-function";
+const invocationStorage = new AsyncLocalStorage();
+const regenerationStorage = new AsyncLocalStorage();
+let responseStore;
+/** Connect the generated Cloudflare worker entry to the configured data adapter. */
+function setResponseStore(store) {
+	responseStore = store;
+}
+/** Associate data-cache writes with the response-stage invocation that produced them. */
+function runWithResponseStoreInvocation(serialized, replayable, callback, capture) {
+	return invocationStorage.run({
+		capture,
+		replayable,
+		serialized
+	}, callback);
+}
+/** Retain the RSC side stream only when the outer response-store invocation requested it. */
+function captureResponseStoreRscData(rscData) {
+	const capture = invocationStorage.getStore()?.capture;
+	if (capture?.captureRscData) capture.rscData = rscData;
+	else rscData.catch(() => {});
+}
+/** Stream the foreground body while retaining an independent admission branch. */
+function deferResponseStoreAdmission(response, complete) {
+	const capture = invocationStorage.getStore()?.capture;
+	if (!capture?.streamResponse || !response.body) return null;
+	const source = response.body.getReader();
+	const admission = new TransformStream(void 0, { highWaterMark: 0 }, { highWaterMark: 0 });
+	const writer = admission.writable.getWriter();
+	let admissionOpen = true;
+	let foregroundCancelled = false;
+	let foregroundCancelReason;
+	let writerReleased = false;
+	const releaseSource = () => {
+		try {
+			source.releaseLock();
+		} catch {}
+	};
+	const releaseWriter = () => {
+		if (writerReleased) return;
+		writerReleased = true;
+		try {
+			writer.releaseLock();
+		} catch {}
+	};
+	const cancelSource = (reason) => {
+		try {
+			const cancellation = source.cancel(reason);
+			releaseSource();
+			cancellation.catch(() => {}).finally(releaseSource);
+		} catch {
+			releaseSource();
+		}
+	};
+	const finishAdmission = async (failure) => {
+		if (!admissionOpen) return;
+		admissionOpen = false;
+		if (failure && foregroundCancelled) cancelSource(foregroundCancelReason);
+		try {
+			if (failure) await writer.abort(failure.reason);
+			else await writer.close();
+		} catch {} finally {
+			releaseWriter();
+		}
+	};
+	const writeAdmission = async (chunk) => {
+		if (!admissionOpen) return;
+		try {
+			await writer.write(chunk);
+		} catch {
+			admissionOpen = false;
+			releaseWriter();
+		}
+	};
+	const foreground = new ReadableStream({
+		async pull(controller) {
+			try {
+				const result = await source.read();
+				if (result.done) {
+					releaseSource();
+					controller.close();
+					await finishAdmission();
+					return;
+				}
+				controller.enqueue(result.value);
+				await writeAdmission(result.value);
+			} catch (error) {
+				releaseSource();
+				controller.error(error);
+				await finishAdmission({ reason: error });
+			}
+		},
+		cancel(reason) {
+			foregroundCancelled = true;
+			foregroundCancelReason = reason;
+			if (!admissionOpen) {
+				cancelSource(reason);
+				return;
+			}
+			(async () => {
+				try {
+					while (true) {
+						const result = await source.read();
+						if (result.done) break;
+						await writeAdmission(result.value);
+						if (!admissionOpen) {
+							cancelSource(reason);
+							break;
+						}
+					}
+					releaseSource();
+					await finishAdmission();
+				} catch (error) {
+					releaseSource();
+					await finishAdmission({ reason: error });
+				}
+			})();
+		}
+	}, { highWaterMark: 0 });
+	capture.admittedResponse = complete(new Response(admission.readable, response));
+	capture.admittedResponse.catch((error) => finishAdmission({ reason: error }));
+	writer.closed.catch((error) => finishAdmission({ reason: error }));
+	return new Response(foreground, response);
+}
+/** 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);
+	if (!scope.captured) throw new Error(`vinext response-store regeneration did not rewrite data key ${key}`);
+	return scope.captured;
+}
+function readCacheControlField(context, field) {
+	const cacheControl = context?.cacheControl;
+	const value = cacheControl && typeof cacheControl === "object" ? Reflect.get(cacheControl, field) : context?.[field];
+	return typeof value === "number" || field === "revalidate" && value === false ? value : void 0;
+}
+async function digest(value) {
+	const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+	return Buffer.from(bytes).toString("hex");
+}
+async function cacheRequest(key, path = DATA_ENTRY_PATH) {
+	return new Request(`https://vinext-data-cache.invalid/${path}/${await digest(key)}`);
+}
+function readStringArrayField(context, field) {
+	const value = context?.[field];
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function serialize(entry) {
+	return JSON.stringify(entry, (_key, value) => value instanceof ArrayBuffer ? { [ARRAY_BUFFER_MARKER]: Buffer.from(value).toString("base64") } : value);
+}
+function deserialize(value) {
+	let entry;
+	try {
+		entry = JSON.parse(value, (_key, item) => {
+			if (item && typeof item === "object" && typeof Reflect.get(item, ARRAY_BUFFER_MARKER) === "string") {
+				const bytes = Buffer.from(Reflect.get(item, ARRAY_BUFFER_MARKER), "base64");
+				return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+			}
+			return item;
+		});
+	} catch {
+		return null;
+	}
+	if (!entry || typeof entry !== "object" || typeof Reflect.get(entry, "lastModified") !== "number") return null;
+	const cachedValue = Reflect.get(entry, "value");
+	if (cachedValue !== null && (!cachedValue || typeof cachedValue !== "object" || typeof Reflect.get(cachedValue, "kind") !== "string")) return null;
+	return entry;
+}
+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)}`;
+}
+var WorkersResponseStoreCacheHandler = class {
+	store;
+	tagExpirations = cacheForRequest(() => /* @__PURE__ */ new Map());
+	constructor(store = responseStore) {
+		this.store = store;
+		if (!store) throw new Error("[vinext] The Workers Response Store adapter must run through its generated Cloudflare worker entry.");
+	}
+	async get(key, context) {
+		if (regenerationStorage.getStore()?.targetKey === key) return null;
+		const request = await cacheRequest(key);
+		const response = await this.store.fetch(request);
+		if (response.status === 404 && response.headers.get("X-Workers-Response-Store") === "MISS") return null;
+		if (!response.ok) throw new Error(`Workers Response Store returned ${response.status}`);
+		const softTags = [...new Set(readStringArrayField(context, "softTags").map(encodeCloudflareCacheTag))].sort();
+		const getTagExpiration = () => {
+			const key = softTags.join(",");
+			const expirations = this.tagExpirations();
+			let expiration = expirations.get(key);
+			if (!expiration) {
+				expiration = Promise.resolve().then(() => this.store.getTagExpiration(softTags));
+				expirations.set(key, expiration);
+				expiration.catch(() => {
+					if (expirations.get(key) === expiration) expirations.delete(key);
+				});
+			}
+			return expiration;
+		};
+		const storeStatus = response.headers.get("X-Workers-Response-Store");
+		const body = response.text();
+		const eagerExpiration = softTags.length && (storeStatus === "BLOB-FRESH" || storeStatus === "BLOB-STALE") ? getTagExpiration().then((value) => ({ value }), (error) => ({ error })) : void 0;
+		const entry = deserialize(await body);
+		if (!entry) {
+			await this.store.purge({ pathPrefixes: [new URL(request.url).pathname] });
+			return null;
+		}
+		if (softTags.length) {
+			const expiration = eagerExpiration ? await eagerExpiration : { value: await getTagExpiration() };
+			if ("error" in expiration) throw expiration.error;
+			if (expiration.value >= entry.lastModified) return null;
+		}
+		const age = Date.now() - entry.lastModified;
+		const requestedRevalidate = readCacheControlField(context, "revalidate");
+		const requestedStale = typeof requestedRevalidate === "number" && requestedRevalidate > 0 && age > requestedRevalidate * 1e3;
+		let cacheState;
+		if (response.headers.get(REPLAYABLE_HEADER) === "1") {
+			if (requestedStale) 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";
+		return {
+			lastModified: entry.lastModified,
+			value: entry.value,
+			...cacheState ? { cacheState } : {},
+			...entry.cacheControl ? { cacheControl: entry.cacheControl } : {}
+		};
+	}
+	async set(key, value, context) {
+		let revalidate = readCacheControlField(context, "revalidate");
+		if (value && "revalidate" in value) revalidate = value.revalidate;
+		if (revalidate === 0) return;
+		const rawExpire = readCacheControlField(context, "expire");
+		const expire = typeof rawExpire === "number" ? rawExpire : void 0;
+		const stale = readCacheControlField(context, "stale");
+		const cacheControl = typeof revalidate === "number" || revalidate === false ? {
+			revalidate,
+			...typeof expire === "number" ? { expire } : {},
+			...typeof stale === "number" ? { stale } : {}
+		} : void 0;
+		const tags = /* @__PURE__ */ new Set();
+		if (value && "tags" in value && Array.isArray(value.tags)) for (const tag of value.tags) tags.add(tag);
+		if (Array.isArray(context?.tags)) {
+			for (const tag of context.tags) if (typeof tag === "string") tags.add(tag);
+		}
+		const tagHeader = [...tags].map(encodeCloudflareCacheTag).join(",");
+		if (tagHeader.length > MAX_CACHE_TAG_HEADER_BYTES) throw new Error("Workers Response Store cache tags exceed the Workers Cache header limit");
+		const invocation = invocationStorage.getStore();
+		const cacheFunctionInvocation = context?.cacheFunctionInvocation;
+		const revalidator = cacheFunctionInvocation && typeof cacheFunctionInvocation === "object" && typeof Reflect.get(cacheFunctionInvocation, "referenceId") === "string" && typeof Reflect.get(cacheFunctionInvocation, "encryptedArgs") === "string" ? {
+			id: CACHE_FUNCTION_REVALIDATOR_ID,
+			args: [key, JSON.stringify(cacheFunctionInvocation)]
+		} : invocation?.replayable ? {
+			id: DATA_REVALIDATOR_ID,
+			args: [key, invocation.serialized]
+		} : void 0;
+		const response = new Response(serialize({
+			...cacheControl ? { cacheControl } : {},
+			lastModified: Date.now(),
+			value
+		}), { headers: {
+			"Cache-Control": revalidator ? cachePolicy(revalidate, expire) : CACHE_MAX_AGE,
+			...tagHeader ? { "Cache-Tag": tagHeader } : {},
+			"Content-Type": "application/json",
+			...revalidator ? { [REPLAYABLE_HEADER]: "1" } : {}
+		} });
+		const regeneration = regenerationStorage.getStore();
+		if (regeneration) {
+			if (key === regeneration.targetKey) regeneration.captured = response;
+			return;
+		}
+		await this.store.put(await cacheRequest(key), response, {
+			...revalidator ? { revalidator } : {},
+			coalesce: true,
+			purgeExisting: true
+		});
+	}
+	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 });
+		else await this.store.purge({ tags: encodedTags });
+	}
+};
+function createResponseStoreDataCacheAdapter() {
+	return new WorkersResponseStoreCacheHandler();
+}
+//#endregion
+export { CACHE_FUNCTION_REVALIDATOR_ID, DATA_REVALIDATOR_ID, WorkersResponseStoreCacheHandler, captureResponseStoreDataRegeneration, captureResponseStoreRscData, createResponseStoreDataCacheAdapter as default, deferResponseStoreAdmission, runWithResponseStoreInvocation, setResponseStore };

package/dist/cacheability-artifact.d.ts

@@ -0,0 +1,9 @@
+import { CacheabilityManifest } from "vinext/internal/server/cacheability-manifest";
+//#region src/cacheability-artifact.d.ts
+/**
+ * Write the version-specific manifest into the built Worker artifact.
+ * The application build already imports this stable module asset, so the
+ * completed dist directory remains the exact input to the final upload.
+ */
+export declare function writeCacheabilityManifestArtifact(root: string, configuredPath: string | undefined, manifest: CacheabilityManifest): string;
+//#endregion