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

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,289 @@
+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 entry = deserialize(await response.text());
+		if (!entry) {
+			await this.store.purge({ pathPrefixes: [new URL(request.url).pathname] });
+			return null;
+		}
+		const softTags = [...new Set(readStringArrayField(context, "softTags").map(encodeCloudflareCacheTag))].sort();
+		if (softTags.length) {
+			const key = softTags.join(",");
+			const expirations = this.tagExpirations();
+			let expiration = expirations.get(key);
+			if (!expiration) {
+				expiration = this.store.getTagExpiration(softTags);
+				expirations.set(key, expiration);
+			}
+			if (await expiration >= 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

@@ -5,6 +5,5 @@ import { CacheabilityManifest } from "vinext/internal/server/cacheability-manife
  * The application build already imports this stable module asset, so the
  * completed dist directory remains the exact input to the final upload.
  */
-declare function writeCacheabilityManifestArtifact(root: string, configuredPath: string | undefined, manifest: CacheabilityManifest): string;
-//#endregion
-export { writeCacheabilityManifestArtifact };
+export declare function writeCacheabilityManifestArtifact(root: string, configuredPath: string | undefined, manifest: CacheabilityManifest): string;
+//#endregion

package/dist/cacheability-artifact.js

@@ -135,7 +135,33 @@ function assertManifestModuleReachable(configPath) {
 	if (typeof main !== "string" || main.length === 0) throw new Error("Two-stage CDN warming requires a generated Wrangler main module.");
 	const mainPath = path.resolve(serverDirectory, main);
 	if (!fs.existsSync(mainPath) || !fs.lstatSync(mainPath).isFile()) throw new Error("Two-stage CDN warming could not find the generated Wrangler main module.");
-	if (!hasStaticModuleSpecifier(fs.readFileSync(mainPath, "utf8"), `./${CACHEABILITY_MANIFEST_MODULE}`)) throw new Error(`Two-stage CDN warming requires the generated Worker main module to import ${CACHEABILITY_MANIFEST_MODULE}.`);
+	const viteManifestPath = path.join(serverDirectory, ".vite", "manifest.json");
+	let viteManifest;
+	try {
+		viteManifest = JSON.parse(fs.readFileSync(viteManifestPath, "utf8"));
+	} catch (cause) {
+		throw new Error("Two-stage CDN warming could not read the generated Vite manifest.", { cause });
+	}
+	const normalizedMain = main.replace(/^\.\//, "");
+	const entryKey = Object.entries(viteManifest).find(([, entry]) => entry?.file === normalizedMain)?.[0];
+	const queue = entryKey ? [entryKey] : [];
+	const visited = /* @__PURE__ */ new Set();
+	let reachable = false;
+	while (queue.length > 0 && !reachable) {
+		const key = queue.shift();
+		if (visited.has(key)) continue;
+		visited.add(key);
+		const entry = viteManifest[key];
+		if (!entry || typeof entry.file !== "string") continue;
+		const modulePath = path.resolve(serverDirectory, entry.file);
+		if (fs.existsSync(modulePath) && fs.lstatSync(modulePath).isFile()) {
+			const relativeManifest = path.relative(path.dirname(modulePath), path.join(serverDirectory, CACHEABILITY_MANIFEST_MODULE)).split(path.sep).join("/");
+			const specifier = relativeManifest.startsWith(".") ? relativeManifest : `./${relativeManifest}`;
+			reachable = hasStaticModuleSpecifier(fs.readFileSync(modulePath, "utf8"), specifier);
+		}
+		for (const references of [entry.imports, entry.dynamicImports]) if (Array.isArray(references)) queue.push(...references.filter((value) => typeof value === "string"));
+	}
+	if (!reachable) throw new Error(`Two-stage CDN warming requires the generated Worker graph to statically import ${CACHEABILITY_MANIFEST_MODULE}.`);
 }
 /**
 * Write the version-specific manifest into the built Worker artifact.

package/dist/cacheability-manifest-limits.d.ts

@@ -1,5 +1,4 @@
 //#region src/cacheability-manifest-limits.d.ts
-declare const MAX_CACHEABILITY_MANIFEST_BYTES: number;
-declare function cacheabilityManifestByteLimitError(manifestBytes: number, limit?: number): Error;
-//#endregion
-export { MAX_CACHEABILITY_MANIFEST_BYTES, cacheabilityManifestByteLimitError };
+export declare const MAX_CACHEABILITY_MANIFEST_BYTES: number;
+export declare function cacheabilityManifestByteLimitError(manifestBytes: number, limit?: number): Error;
+//#endregion

package/dist/cacheability-manifest-limits.js

@@ -1,5 +1,5 @@
 //#region src/cacheability-manifest-limits.ts
-const MAX_CACHEABILITY_MANIFEST_BYTES = 2 * 1024 * 1024;
+const MAX_CACHEABILITY_MANIFEST_BYTES = 2097152;
 function cacheabilityManifestByteLimitError(manifestBytes, limit = MAX_CACHEABILITY_MANIFEST_BYTES) {
 	return /* @__PURE__ */ new Error(`Two-stage CDN warming produced a ${manifestBytes}-byte route-pattern cacheability manifest; the limit is ${limit} bytes. Reduce the number or length of route patterns, or split the deployment before retrying.`);
 }

package/dist/cacheability-probe.d.ts

@@ -2,10 +2,10 @@ import { CdnWarmTarget } from "./cdn-warm.js";
 import { CacheabilityManifest } from "vinext/internal/server/cacheability-manifest";
 import { PrerenderRoutePattern } from "vinext/internal/build/prerender-paths";
 //#region src/cacheability-probe.d.ts
-declare const DEFAULT_CACHEABILITY_PROBE_PHASE_TIMEOUT_MS = 120000;
-declare const DEFAULT_CACHEABILITY_PROBE_RETRIES = 2;
-declare const DEFAULT_CACHEABILITY_PROBE_RETRY_DELAY_MS = 1000;
-type CacheabilityProbeProgress = {
+export declare const DEFAULT_CACHEABILITY_PROBE_PHASE_TIMEOUT_MS = 120000;
+export declare const DEFAULT_CACHEABILITY_PROBE_RETRIES = 2;
+export declare const DEFAULT_CACHEABILITY_PROBE_RETRY_DELAY_MS = 1000;
+export type CacheabilityProbeProgress = {
   completed: number;
   dynamic: number;
   failed: number;
@@ -14,7 +14,7 @@ type CacheabilityProbeProgress = {
   static: number;
   total: number;
 };
-type CacheabilityProbeResult = {
+export type CacheabilityProbeResult = {
   cacheableTargets: CdnWarmTarget[];
   classified: number;
   dynamic: number;
@@ -25,8 +25,8 @@ type CacheabilityProbeResult = {
   /** Paired representations admitted only if their own final warm render remains cacheable. */
   speculativeTargets: CdnWarmTarget[];
 };
-declare function readPrerenderSecret(root: string): string;
-declare function probeStagedWorkerCacheability(options: {
+export declare function readPrerenderSecret(root: string): string;
+export declare function probeStagedWorkerCacheability(options: {
   buildId: string;
   concurrency?: number;
   expectedResponseBuildId?: string;
@@ -46,5 +46,4 @@ declare function probeStagedWorkerCacheability(options: {
     maxBytes?: number;
   };
 }): Promise<CacheabilityProbeResult>;
-//#endregion
-export { CacheabilityProbeProgress, CacheabilityProbeResult, DEFAULT_CACHEABILITY_PROBE_PHASE_TIMEOUT_MS, DEFAULT_CACHEABILITY_PROBE_RETRIES, DEFAULT_CACHEABILITY_PROBE_RETRY_DELAY_MS, probeStagedWorkerCacheability, readPrerenderSecret };
+//#endregion