@vinext/cloudflare 1.0.0-beta.1 → 1.0.0-beta.11

package/README.md

@@ -7,7 +7,13 @@ This package provides Cloudflare-specific cache and image backends for vinext:
 
 - **`kvDataAdapter()`** (`@vinext/cloudflare/cache/kv-data-adapter`) — backs the
   data cache (`fetch`, `"use cache"`, `unstable_cache`) with a Workers KV
-  namespace. Also used for ISR in the absence of a CDN adapter.
+  namespace.
+- **`cdnAdapter()`** (`@vinext/cloudflare/cache/cdn-adapter`) — delegates
+  page-level ISR serving and revalidation to Cloudflare Workers Cache through
+  an automatically generated cache-enabled response entrypoint.
+- **`responseStoreAdapter()`** (`@vinext/cloudflare/cache/response-store-adapter`) —
+  uses Workers Response Store for both response and data caching, either in a
+  separate cache Worker or inside the application Worker.
 - **`imagesOptimizer()`** (`@vinext/cloudflare/images/images-optimizer`) — backs
   `next/image` transformations with a Cloudflare Images binding.
 
@@ -32,6 +38,170 @@ export default defineConfig({
 });
 ```
 
+### Workers Cache
+
+`cdnAdapter()` is optional. Configuring it asks the Cloudflare build for two
+Worker entrypoints: the default entrypoint runs middleware and request-time
+routing with caching disabled, while `VinextCachedResponse` lazily loads the
+render stage with Workers Cache enabled. Legacy Cloudflare Vite plugin builds
+write these settings and the version metadata binding to the generated
+`dist/server/wrangler.json`.
+
+```ts
+import { cdnAdapter } from "@vinext/cloudflare/cache/cdn-adapter";
+
+vinext({ cache: { cdn: cdnAdapter() } });
+```
+
+Cloudflare Vite plugin v2 uses Build Output and treats `cloudflare.config.ts`
+as the deployment source of truth. Declare the equivalent policies there:
+
+```ts
+import { defineWorker } from "@cloudflare/vite-plugin/experimental-config";
+import { createWorkersCacheConfig } from "@vinext/cloudflare/cache/config";
+
+const workersCache = await createWorkersCacheConfig();
+
+export default defineWorker({
+  // ...
+  ...workersCache,
+  env: {
+    ...workersCache.env,
+    // Other application bindings...
+  },
+});
+```
+
+The generated version metadata binding lets staged warmup prove that every
+discovery, probe, and fill request reached the uploaded Worker version. Pass
+the same `versionMetadataBinding` to `cdnAdapter()` and
+`createWorkersCacheConfig()` only when the deployment needs a custom binding
+name.
+
+Use `--experimental-warm-cdn-cache` for the two-stage deploy. The default flow
+makes one final fill request per admitted identity. Add `--warm-cdn-certify`
+only when you want an opt-in second, header-only request that must prove every
+planned entry reusable before promotion.
+
+The response entrypoint hashes the complete transport identity into its
+Workers Cache URL, independently of zone Cache Rules, so distinct query and
+representation variants cannot collide.
+
+### Workers Response Store
+
+`responseStoreAdapter()` replaces both `cdnAdapter()` and `kvDataAdapter()`.
+It defaults to a separate cache Worker reached through the `RESPONSE_STORE`
+service binding. `vinext init` writes two collocated source configs:
+`wrangler.jsonc` for the application and `wrangler.response-store.jsonc` for the
+cache Worker. The latter points directly at the installed
+`@cloudflare/workers-response-store` implementation and owns its R2 bucket,
+SQLite Durable Object, Worker name, and cache settings. Edit those configs to
+choose or reuse names, keeping the application service binding aligned with the
+cache Worker name.
+
+The two Workers are deliberately deployed separately. Deploy the Response Store
+when its package or config changes, then deploy the application normally:
+
+```sh
+npx wrangler deploy --config wrangler.response-store.jsonc
+npx @vinext/cloudflare deploy
+```
+
+`vinext-cloudflare deploy` never creates, rewrites, or deploys the Response
+Store Worker.
+
+Cloudflare Vite plugin v2 projects can define the same service-binding setup in
+`cloudflare.config.ts` without a second Wrangler config:
+
+```ts
+import { defineConfig, defineWorker } from "@cloudflare/vite-plugin/experimental-config";
+import { createWorkersResponseStoreServiceBindingConfig } from "@vinext/cloudflare/cache/config";
+
+const responseStore = await createWorkersResponseStoreServiceBindingConfig({
+  accountId: "<your-account-id>",
+  worker: {
+    name: "example-response-store",
+    compatibilityDate: "2026-09-15",
+    compatibilityFlags: ["nodejs_compat"],
+    observability: {
+      enabled: true,
+      headSamplingRate: 1,
+      logs: { enabled: true, invocationLogs: true },
+      traces: { enabled: true, headSamplingRate: 0.1 },
+    },
+  },
+  bucket: "example-response-store-cache-bodies",
+});
+
+export const responseStoreServiceBinding = responseStore.serviceBindingWorker;
+
+export default defineConfig({
+  accountId: responseStore.accountId,
+  worker: defineWorker({
+    ...responseStore.applicationWorker,
+    name: "example",
+    entrypoint: "./worker.ts",
+  }),
+});
+```
+
+`worker.observability` accepts the full observability configuration supported by
+your installed Cloudflare Vite plugin, including logs and traces settings.
+The optional `accountId` is returned at the top level: pass it to `defineConfig`,
+not to either Worker. It applies to both Workers in the project.
+
+The async config helpers import bindings and exports from your installed
+`@cloudflare/vite-plugin/experimental-config`. The plugin is an optional peer
+dependency of `@vinext/cloudflare`; these helpers require v2, but Wrangler-only
+projects do not need it.
+
+Register the exported auxiliary Worker with the Cloudflare Vite plugin so it
+is built alongside the application:
+
+```ts
+import { cloudflare } from "@cloudflare/vite-plugin";
+import { responseStoreServiceBinding } from "./cloudflare.config.ts";
+
+cloudflare({ auxiliaryWorkers: [{ config: responseStoreServiceBinding }] });
+```
+
+Metadata sharding is opt-in and works in either deployment mode:
+
+```ts
+vinext({ cache: responseStoreAdapter({ shards: 16 }) });
+```
+
+Keys remain pinned to one shard while tag/path mutations fan out across every
+shard. Omit `shards` to retain the original single metadata Durable Object.
+
+To place newly created metadata Durable Objects near a stable traffic and R2
+region, pass a Cloudflare location hint:
+
+```ts
+vinext({ cache: responseStoreAdapter({ locationHint: "weur" }) });
+```
+
+The hint works in both deployment modes, is best-effort, and only affects each
+Durable Object's first creation. Changing it does not relocate existing
+objects; treat the change as a cache-cold deployment and align it with the R2
+bucket's location.
+
+To deploy storage and cache entrypoints with the application instead, select
+self-contained mode:
+
+```ts
+import { responseStoreAdapter } from "@vinext/cloudflare/cache/response-store-adapter";
+
+vinext({ cache: responseStoreAdapter({ mode: "self-contained" }) });
+```
+
+The corresponding typed config helper is
+`createWorkersResponseStoreSelfContainedConfig`.
+
+In this mode `vinext init` places the required R2, SQLite Durable Object,
+Workers Cache entrypoint, and version-metadata configuration in
+`wrangler.jsonc`; no second Wrangler config is required.
+
 ## Deploy
 
 Deploy Cloudflare Workers projects with the package CLI:
@@ -40,5 +210,27 @@ Deploy Cloudflare Workers projects with the package CLI:
 npx @vinext/cloudflare deploy
 ```
 
+Projects with `cloudflare.config.ts` opt into the experimental Cloudflare Vite
+plugin v2 path and deploy their generated Build Output with `cf`. Existing
+Wrangler-configured projects continue to use Wrangler. A normal typed-config
+deploy needs neither `wrangler.jsonc` nor the Wrangler package.
+
+`vinext-cloudflare deploy` only deploys the entry Worker. It never deploys named
+auxiliary Workers, including during staged warming or `--no-promote` uploads.
+Deploy a configured Response Store Worker explicitly after building, when first
+setting it up or when its code/config changes:
+
+```sh
+cf deploy --prebuilt --mode production --worker example-response-store
+```
+
+Use the mode and Worker name from your build. `cloudflare.config.ts` remains the
+source of truth; no auxiliary Wrangler config is required.
+
+Experimental staged CDN warming uses `cf` to upload a version, read deployment
+status, stage and promote traffic, and apply triggers. Typed-config projects do
+not need an equivalent Wrangler config. Existing Wrangler-configured projects
+continue to use Wrangler for this flow.
+
 With Vite+, use `vpx @vinext/cloudflare deploy`, or
 `vp exec vinext-cloudflare deploy` when running the locally installed bin.

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

@@ -0,0 +1,31 @@
+//#region src/cache/cdn-adapter-config.d.ts
+type WranglerWorkerExport = {
+  cache?: {
+    enabled: boolean;
+  };
+  type?: string;
+  [key: string]: unknown;
+};
+type WranglerOutputConfig = {
+  compatibility_date?: string;
+  compatibility_flags?: string[];
+  exports?: Record<string, WranglerWorkerExport>;
+  version_metadata?: unknown;
+  [key: string]: unknown;
+};
+type VersionMetadataOptions = {
+  binding: string;
+  bindingIsExplicit: boolean;
+};
+export declare function configureCdnVersionMetadata(config: WranglerOutputConfig, options: VersionMetadataOptions): WranglerOutputConfig;
+/** Add the per-entrypoint Workers Cache policy to an emitted Wrangler config. */
+export declare function configureWorkersCacheEntrypoints(config: WranglerOutputConfig): WranglerOutputConfig;
+/** Apply the complete CDN adapter policy to the primary generated config. */
+export declare function finalizeCdnAdapterBuildOutput({ root, outDir, isPrimaryServerOutput, binding, bindingIsExplicit }: {
+  root: string;
+  outDir: string;
+  isPrimaryServerOutput: boolean;
+  binding: string;
+  bindingIsExplicit: boolean;
+}): Promise<void>;
+//#endregion

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

@@ -0,0 +1,95 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region src/cache/cdn-adapter-config.ts
+const CACHED_RESPONSE_STAGE_EXPORT = "VinextCachedResponse";
+const UNCACHED_RESPONSE_STAGE_EXPORT = "VinextUncachedResponse";
+const CTX_EXPORTS_DEFAULT_DATE = "2025-11-17";
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function configureCdnVersionMetadata(config, options) {
+	if (!Object.hasOwn(config, "version_metadata")) return {
+		...config,
+		version_metadata: { binding: options.binding }
+	};
+	if (!isRecord(config.version_metadata)) throw new Error("[vinext] The generated Wrangler config has an invalid version_metadata value.");
+	const existingBinding = config.version_metadata.binding;
+	if (typeof existingBinding !== "string" || existingBinding.length === 0) throw new Error("[vinext] The generated Wrangler config has an invalid version_metadata.binding value.");
+	if (existingBinding === options.binding) return config;
+	if (!options.bindingIsExplicit) throw new Error(`[vinext] cdnAdapter() uses the default version metadata binding ${JSON.stringify(options.binding)}, but the generated Wrangler config already declares ${JSON.stringify(existingBinding)}. Align the Wrangler binding or configure cdnAdapter({ versionMetadataBinding: ${JSON.stringify(existingBinding)} }).`);
+	return {
+		...config,
+		version_metadata: { binding: options.binding }
+	};
+}
+/** Add the per-entrypoint Workers Cache policy to an emitted Wrangler config. */
+function configureWorkersCacheEntrypoints(config) {
+	const configuredExports = config.exports ?? {};
+	const compatibilityFlags = config.compatibility_flags ?? [];
+	if (compatibilityFlags.includes("disable_ctx_exports")) throw new Error("[vinext] cdnAdapter() requires ctx.exports, but the generated Wrangler config explicitly disables it with disable_ctx_exports.");
+	const configuredCompatibilityFlags = config.compatibility_date === void 0 || config.compatibility_date < CTX_EXPORTS_DEFAULT_DATE ? compatibilityFlags.includes("enable_ctx_exports") ? compatibilityFlags : [...compatibilityFlags, "enable_ctx_exports"] : compatibilityFlags.filter((flag) => flag !== "enable_ctx_exports");
+	for (const name of [
+		"default",
+		CACHED_RESPONSE_STAGE_EXPORT,
+		UNCACHED_RESPONSE_STAGE_EXPORT
+	]) {
+		const existing = configuredExports[name];
+		if (existing?.type !== void 0 && existing.type !== "worker") throw new Error(`[vinext] cdnAdapter() cannot configure the reserved Worker export ${JSON.stringify(name)} because it is already declared as ${JSON.stringify(existing.type)}.`);
+	}
+	return {
+		...config,
+		compatibility_flags: configuredCompatibilityFlags,
+		exports: {
+			...configuredExports,
+			default: {
+				...configuredExports.default,
+				type: "worker",
+				cache: { enabled: false }
+			},
+			[CACHED_RESPONSE_STAGE_EXPORT]: {
+				...configuredExports[CACHED_RESPONSE_STAGE_EXPORT],
+				type: "worker",
+				cache: { enabled: true }
+			},
+			[UNCACHED_RESPONSE_STAGE_EXPORT]: {
+				...configuredExports[UNCACHED_RESPONSE_STAGE_EXPORT],
+				type: "worker",
+				cache: { enabled: false }
+			}
+		}
+	};
+}
+async function readGeneratedConfig(generatedConfigPath, allowMissing) {
+	try {
+		const parsed = JSON.parse(await fs.readFile(generatedConfigPath, "utf8"));
+		if (!isRecord(parsed)) throw new TypeError("the root value must be an object");
+		return parsed;
+	} catch (cause) {
+		if (allowMissing && cause !== null && typeof cause === "object" && "code" in cause && cause.code === "ENOENT") return null;
+		throw new Error(`[vinext] Could not read the generated Wrangler config at ${generatedConfigPath}.`, { cause });
+	}
+}
+async function writeGeneratedConfig(generatedConfigPath, config) {
+	await fs.writeFile(generatedConfigPath, `${JSON.stringify(config, null, 2)}\n`);
+}
+async function usesCloudflareBuildOutput(root) {
+	try {
+		return (await fs.stat(path.resolve(root, "cloudflare.config.ts"))).isFile();
+	} catch (cause) {
+		if (cause !== null && typeof cause === "object" && "code" in cause && cause.code === "ENOENT") return false;
+		throw cause;
+	}
+}
+/** Apply the complete CDN adapter policy to the primary generated config. */
+async function finalizeCdnAdapterBuildOutput({ root, outDir, isPrimaryServerOutput, binding, bindingIsExplicit }) {
+	if (!isPrimaryServerOutput) return;
+	const generatedConfigPath = path.resolve(outDir, "wrangler.json");
+	const generatedConfig = await readGeneratedConfig(generatedConfigPath, await usesCloudflareBuildOutput(root));
+	if (!generatedConfig) return;
+	await writeGeneratedConfig(generatedConfigPath, configureWorkersCacheEntrypoints(configureCdnVersionMetadata(generatedConfig, {
+		binding,
+		bindingIsExplicit
+	})));
+}
+//#endregion
+export { configureCdnVersionMetadata, configureWorkersCacheEntrypoints, finalizeCdnAdapterBuildOutput };

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

@@ -1,25 +1,58 @@
 //#region src/cache/cdn-adapter.d.ts
+export declare const DEFAULT_CDN_VERSION_METADATA_BINDING = "CF_VERSION_METADATA";
+/** Options accepted by {@link cdnAdapter}, forwarded to the runtime factory. */
+export type CdnAdapterOptions = {
+  /** Version metadata binding used to verify version-overridden requests. */
+  versionMetadataBinding?: string;
+};
 /**
  * Cloudflare CDN cache adapter - edge-managed page-level ISR backed by the
  * Cloudflare Workers Cache.
  *
  * Unlike the data adapter (which stores cache entries in a durable store and
- * serves HIT/STALE itself), this adapter delegates serving to Cloudflare's
- * edge cache.
+ * 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.
+ *
+ * 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.
  *
- * Workers Cache must be enabled in your Wrangler config for this to work.
- * ```jsonc
- * // wrangler.jsonc
- * {
- *   "cache": {
- *     "enabled": true,
- *   },
- * }
- * ```
+ * The adapter adds a transport-only URL digest so distinct response-stage
+ * identities cannot collide. Workers Cache owns this key independently of
+ * zone Cache Rules.
  */
-declare function cdnAdapter(options?: Record<string, never>): {
+export declare function cdnAdapter(options?: CdnAdapterOptions): {
   adapter: string;
-  options: Record<string, never> | undefined;
+  options: CdnAdapterOptions | undefined;
+  output: {
+    entry: string;
+    matchesBuild({ plugins }: {
+      plugins: readonly {
+        name?: string;
+      }[];
+    }): boolean;
+    transformHostEntry({ code, id }: {
+      code: string;
+      id: string;
+    }): string | null;
+    finalizeBuildOutput({ root, outDir, isPrimaryServerOutput }: {
+      root: string;
+      outDir: string;
+      isPrimaryServerOutput: boolean;
+    }): Promise<void>;
+    type: "multi-stage";
+  };
+  capabilities: {
+    buildIdentity: "response-header";
+    isResponsePolicyHeader: (name: string) => boolean;
+    requestRouting: "uncached-stage";
+    responseVary: "verbatim";
+    routeCacheability: "probe-manifest";
+  };
 };
-//#endregion
-export { cdnAdapter };
+//#endregion

package/dist/cache/cdn-adapter.js

@@ -1,28 +1,65 @@
+import { finalizeCdnAdapterBuildOutput } from "./cdn-adapter-config.js";
 import { fileURLToPath } from "node:url";
 //#region src/cache/cdn-adapter.ts
+const DEFAULT_CDN_VERSION_METADATA_BINDING = "CF_VERSION_METADATA";
+const CLOUDFLARE_WORKER_ENTRY_ID = "virtual:cloudflare/worker-entry";
 /**
 * Cloudflare CDN cache adapter - edge-managed page-level ISR backed by the
 * Cloudflare Workers Cache.
 *
 * Unlike the data adapter (which stores cache entries in a durable store and
-* serves HIT/STALE itself), this adapter delegates serving to Cloudflare's
-* edge cache.
+* 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.
 *
-* Workers Cache must be enabled in your Wrangler config for this to work.
-* ```jsonc
-* // wrangler.jsonc
-* {
-*   "cache": {
-*     "enabled": true,
-*   },
-* }
-* ```
+* 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.
+*
+* The adapter adds a transport-only URL digest so distinct response-stage
+* identities cannot collide. Workers Cache owns this key independently of
+* zone Cache Rules.
 */
 function cdnAdapter(options) {
+	if (options?.versionMetadataBinding !== void 0 && (typeof options.versionMetadataBinding !== "string" || options.versionMetadataBinding.length === 0)) throw new TypeError("[vinext] cdnAdapter({ versionMetadataBinding }) must be a non-empty string binding name.");
+	const versionMetadataBinding = options?.versionMetadataBinding ?? "CF_VERSION_METADATA";
+	const bindingIsExplicit = options?.versionMetadataBinding !== void 0;
+	const workerEntry = fileURLToPath(import.meta.resolve("./cdn-adapter.worker.js"));
 	return {
 		adapter: fileURLToPath(import.meta.resolve("./cdn-adapter.runtime.js")),
-		options
+		options,
+		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 { VinextCachedResponse, VinextUncachedResponse } from ${JSON.stringify(workerEntry)};\n`;
+			},
+			finalizeBuildOutput({ root, outDir, isPrimaryServerOutput }) {
+				return finalizeCdnAdapterBuildOutput({
+					root,
+					outDir,
+					isPrimaryServerOutput,
+					binding: versionMetadataBinding,
+					bindingIsExplicit
+				});
+			},
+			type: "multi-stage"
+		},
+		capabilities: {
+			buildIdentity: "response-header",
+			isResponsePolicyHeader: (name) => name.toLowerCase() === "cdn-cache-control" || name.toLowerCase() === "cloudflare-cdn-cache-control",
+			requestRouting: "uncached-stage",
+			responseVary: "verbatim",
+			routeCacheability: "probe-manifest"
+		}
 	};
 }
 //#endregion
-export { cdnAdapter };
+export { DEFAULT_CDN_VERSION_METADATA_BINDING, cdnAdapter };

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

@@ -1,8 +1,26 @@
 import { CdnCacheAdapter, CdnCacheableHeaderInput, CdnResponseHeaders } from "vinext/shims/cdn-cache";
 import { CacheHandlerValue, IncrementalCacheValue } from "vinext/shims/cache";
-
 //#region src/cache/cdn-adapter.runtime.d.ts
-declare class CloudflareCdnCacheAdapter implements CdnCacheAdapter {
+type WorkerVersionMetadata = {
+  id: string;
+};
+type CdnAdapterOptions = {
+  versionMetadataBinding?: string;
+};
+/** Encode a case-sensitive Next.js tag into a fixed Workers Cache tag. */
+export declare function encodeCloudflareCacheTag(tag: string): string;
+export declare class CloudflareCdnCacheAdapter implements CdnCacheAdapter {
+  private readonly versionMetadata?;
+  private readonly versionMetadataBinding;
+  readonly requiresCompletedResponseAdmission = true;
+  readonly responseVary: "verbatim";
+  readonly responsePolicy: {
+    isHeader(name: string): boolean;
+    readCacheControl(headers: Headers): string | null;
+    hasExplicitNonCacheablePolicy(headers: Headers, baseline?: Headers): boolean;
+  };
+  constructor(versionMetadata?: WorkerVersionMetadata | undefined, versionMetadataBinding?: string);
+  validateRequest(request: Request): Response | null;
   readonly ownsBackgroundRevalidation = false;
   /**
    * The origin keeps no page store — return null so the request renders fresh.
@@ -11,12 +29,16 @@ declare class CloudflareCdnCacheAdapter implements CdnCacheAdapter {
   get(): Promise<CacheHandlerValue | null>;
   /** No-op: the platform caches the response via its headers, not an origin store. */
   set(_key: string, _data: IncrementalCacheValue | null, _ctx?: Record<string, unknown>): Promise<void>;
+  buildResponseIdentityHeaders(): CdnResponseHeaders;
   buildResponseHeaders(input: CdnCacheableHeaderInput): CdnResponseHeaders;
   /** Purge edge-cached responses by tag via the request context's `cache.purge`. */
   revalidateTag(tags: string | string[], _durations?: {
     expire?: number;
   }): Promise<void>;
 }
-declare const createCloudflareCdnCacheAdapter: () => CdnCacheAdapter;
+declare const createCloudflareCdnCacheAdapter: ({ env, options }?: {
+  env?: Record<string, unknown>;
+  options?: CdnAdapterOptions;
+}) => CdnCacheAdapter;
 //#endregion
-export { CloudflareCdnCacheAdapter, createCloudflareCdnCacheAdapter as default };
+export { createCloudflareCdnCacheAdapter as default };