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

package/README.md

@@ -43,10 +43,9 @@ export default defineConfig({
 `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. These settings are written to the
-generated `dist/server/wrangler.json`; do not enable Workers Cache on the
-default entrypoint in your source config. The generated config also declares
-the version metadata binding used for staged warmup.
+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";
@@ -54,10 +53,30 @@ 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
-`versionMetadataBinding` to `cdnAdapter()` only when the deployment needs a
-custom binding name.
+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`
@@ -91,6 +110,61 @@ 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
@@ -121,6 +195,9 @@ import { responseStoreAdapter } from "@vinext/cloudflare/cache/response-store-ad
 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.
@@ -133,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

@@ -21,7 +21,8 @@ export declare function configureCdnVersionMetadata(config: 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({ outDir, isPrimaryServerOutput, binding, bindingIsExplicit }: {
+export declare function finalizeCdnAdapterBuildOutput({ root, outDir, isPrimaryServerOutput, binding, bindingIsExplicit }: {
+  root: string;
   outDir: string;
   isPrimaryServerOutput: boolean;
   binding: string;

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

@@ -72,11 +72,19 @@ async function readGeneratedConfig(generatedConfigPath, allowMissing) {
 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({ outDir, isPrimaryServerOutput, binding, bindingIsExplicit }) {
+async function finalizeCdnAdapterBuildOutput({ root, outDir, isPrimaryServerOutput, binding, bindingIsExplicit }) {
 	if (!isPrimaryServerOutput) return;
 	const generatedConfigPath = path.resolve(outDir, "wrangler.json");
-	const generatedConfig = await readGeneratedConfig(generatedConfigPath, false);
+	const generatedConfig = await readGeneratedConfig(generatedConfigPath, await usesCloudflareBuildOutput(root));
 	if (!generatedConfig) return;
 	await writeGeneratedConfig(generatedConfigPath, configureWorkersCacheEntrypoints(configureCdnVersionMetadata(generatedConfig, {
 		binding,

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

@@ -15,12 +15,12 @@ export type CdnAdapterOptions = {
  * request-time routing before dispatching to cached or uncached response-stage
  * entrypoints.
  *
- * The emitted Wrangler configuration enables Workers Cache only for that
- * response-stage export, so cache hits do not start the application stage.
- * The generated deployment config automatically enables Workers Cache for the
- * cached response entrypoint and adds the version metadata binding used by
- * warmup. The uncached response entrypoint keeps bypass and probe renders out
- * of the gateway without enabling Workers Cache for them.
+ * 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
@@ -40,7 +40,8 @@ export declare function cdnAdapter(options?: CdnAdapterOptions): {
       code: string;
       id: string;
     }): string | null;
-    finalizeBuildOutput({ outDir, isPrimaryServerOutput }: {
+    finalizeBuildOutput({ root, outDir, isPrimaryServerOutput }: {
+      root: string;
       outDir: string;
       isPrimaryServerOutput: boolean;
     }): Promise<void>;

package/dist/cache/cdn-adapter.js

@@ -13,12 +13,12 @@ const CLOUDFLARE_WORKER_ENTRY_ID = "virtual:cloudflare/worker-entry";
 * request-time routing before dispatching to cached or uncached response-stage
 * entrypoints.
 *
-* The emitted Wrangler configuration enables Workers Cache only for that
-* response-stage export, so cache hits do not start the application stage.
-* The generated deployment config automatically enables Workers Cache for the
-* cached response entrypoint and adds the version metadata binding used by
-* warmup. The uncached response entrypoint keeps bypass and probe renders out
-* of the gateway without enabling Workers Cache for them.
+* 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
@@ -41,8 +41,9 @@ function cdnAdapter(options) {
 				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({ outDir, isPrimaryServerOutput }) {
+			finalizeBuildOutput({ root, outDir, isPrimaryServerOutput }) {
 				return finalizeCdnAdapterBuildOutput({
+					root,
 					outDir,
 					isPrimaryServerOutput,
 					binding: versionMetadataBinding,

package/dist/cache/cdn-build-id.d.ts

@@ -1,6 +1,6 @@
 //#region src/cache/cdn-build-id.d.ts
 /** Build identity stamped by the Cloudflare CDN adapter on page responses. */
 export declare const VINEXT_CDN_BUILD_ID_HEADER = "X-Vinext-Build-Id";
-/** Opaque identity shared by every server entry emitted by one vinext build. */
+/** Opaque identity shared by every server entry emitted by one vite build. */
 export declare function getVinextCdnBuildIdentity(): string | null;
 //#endregion

package/dist/cache/cdn-build-id.js

@@ -1,7 +1,7 @@
 //#region src/cache/cdn-build-id.ts
 /** Build identity stamped by the Cloudflare CDN adapter on page responses. */
 const VINEXT_CDN_BUILD_ID_HEADER = "X-Vinext-Build-Id";
-/** Opaque identity shared by every server entry emitted by one vinext build. */
+/** Opaque identity shared by every server entry emitted by one vite build. */
 function getVinextCdnBuildIdentity() {
 	return process.env.__VINEXT_RSC_BUILD_IDENTITY || process.env.__VINEXT_BUILD_ID || null;
 }

package/dist/cache/config.d.ts

@@ -0,0 +1,137 @@
+import { CloudflareConfig, WorkerConfig } from "@cloudflare/vite-plugin/experimental-config";
+//#region src/cache/config.d.ts
+type ResponseStoreStorageOptions = {
+  worker: string;
+  bucket: string;
+};
+export declare function createWorkersResponseStoreSelfContainedConfig(options: ResponseStoreStorageOptions): Promise<{
+  cache: {
+    enabled: true;
+  };
+  exports: {
+    CacheMetadata: {
+      state?: "created";
+      type: "durable-object";
+      storage: "sqlite";
+      container: undefined;
+    } | {
+      state?: "created";
+      type: "durable-object";
+      storage: "sqlite";
+      container: undefined;
+    };
+    ResponseStoreBinding: import("@cloudflare/vite-plugin/experimental-config").WorkerEntrypointExport;
+  };
+  env: {
+    CACHE_BODIES: import("@cloudflare/vite-plugin/experimental-config").R2Binding;
+    CACHE_METADATA: {
+      type: "durable-object";
+      worker: string;
+      exportName: string;
+    };
+    CF_VERSION_METADATA: import("@cloudflare/vite-plugin/experimental-config").VersionMetadataBinding;
+  };
+}>;
+export declare function createWorkersResponseStoreServiceBindingConfig(options: {
+  accountId?: CloudflareConfig["accountId"];
+  worker: {
+    name: string;
+    compatibilityDate: string;
+    compatibilityFlags?: string[];
+    observability?: WorkerConfig["observability"];
+  };
+  bucket: string;
+}): Promise<{
+  accountId: string | undefined;
+  serviceBindingWorker: {
+    cache: {
+      enabled: true;
+    };
+    exports: {
+      CacheMetadata: {
+        state?: "created";
+        type: "durable-object";
+        storage: "sqlite";
+        container: undefined;
+      } | {
+        state?: "created";
+        type: "durable-object";
+        storage: "sqlite";
+        container: undefined;
+      };
+      ResponseStoreBinding: import("@cloudflare/vite-plugin/experimental-config").WorkerEntrypointExport;
+    };
+    env: {
+      CACHE_BODIES: import("@cloudflare/vite-plugin/experimental-config").R2Binding;
+      CACHE_METADATA: {
+        type: "durable-object";
+        worker: string;
+        exportName: string;
+      };
+    };
+    name: string;
+    compatibilityDate: string;
+    compatibilityFlags?: string[];
+    observability?: WorkerConfig["observability"];
+    entrypoint: string;
+    workersDev: false;
+    previewUrls: false;
+  };
+  applicationWorker: {
+    cache: {
+      enabled: false;
+    };
+    env: {
+      RESPONSE_STORE: import("@cloudflare/vite-plugin/experimental-config").WorkerBinding<{
+        cache: {
+          enabled: true;
+        };
+        exports: {
+          CacheMetadata: {
+            state?: "created";
+            type: "durable-object";
+            storage: "sqlite";
+            container: undefined;
+          } | {
+            state?: "created";
+            type: "durable-object";
+            storage: "sqlite";
+            container: undefined;
+          };
+          ResponseStoreBinding: import("@cloudflare/vite-plugin/experimental-config").WorkerEntrypointExport;
+        };
+        env: {
+          CACHE_BODIES: import("@cloudflare/vite-plugin/experimental-config").R2Binding;
+          CACHE_METADATA: {
+            type: "durable-object";
+            worker: string;
+            exportName: string;
+          };
+        };
+        name: string;
+        compatibilityDate: string;
+        compatibilityFlags?: string[];
+        observability?: WorkerConfig["observability"];
+        entrypoint: string;
+        workersDev: false;
+        previewUrls: false;
+      }, "ResponseStoreService">;
+      CF_VERSION_METADATA: import("@cloudflare/vite-plugin/experimental-config").VersionMetadataBinding;
+    };
+  };
+}>;
+export declare function createWorkersCacheConfig({ versionMetadataBinding }?: {
+  versionMetadataBinding?: string;
+}): Promise<{
+  cache: {
+    enabled: false;
+  };
+  env: {
+    [versionMetadataBinding]: import("@cloudflare/vite-plugin/experimental-config").VersionMetadataBinding;
+  };
+  exports: {
+    VinextCachedResponse: import("@cloudflare/vite-plugin/experimental-config").WorkerEntrypointExport;
+    VinextUncachedResponse: import("@cloudflare/vite-plugin/experimental-config").WorkerEntrypointExport;
+  };
+}>;
+//#endregion

package/dist/cache/config.js

@@ -0,0 +1,87 @@
+//#region src/cache/config.ts
+const RESPONSE_STORE_BINDING = "RESPONSE_STORE";
+const RESPONSE_STORE_ENTRYPOINT = "ResponseStoreService";
+const DEFAULT_VERSION_METADATA_BINDING = "CF_VERSION_METADATA";
+const CACHE_BODIES_BINDING = "CACHE_BODIES";
+const CACHE_METADATA_BINDING = "CACHE_METADATA";
+const CACHE_METADATA_CLASS = "CacheMetadata";
+const RESPONSE_STORE_CACHE_ENTRYPOINT = "ResponseStoreBinding";
+const RESPONSE_STORE_SERVICE_ENTRYPOINT = "@cloudflare/workers-response-store/service";
+async function createResponseStoreWorkerConfig(options) {
+	const { bindings, exports } = await import("@cloudflare/vite-plugin/experimental-config");
+	return {
+		cache: { enabled: true },
+		exports: {
+			[CACHE_METADATA_CLASS]: {
+				...exports.durableObject({ storage: "sqlite" }),
+				storage: "sqlite",
+				container: void 0
+			},
+			[RESPONSE_STORE_CACHE_ENTRYPOINT]: exports.worker({ cache: { enabled: true } })
+		},
+		env: {
+			[CACHE_BODIES_BINDING]: bindings.r2({ name: options.bucket }),
+			[CACHE_METADATA_BINDING]: {
+				...bindings.durableObject({
+					worker: options.worker,
+					exportName: CACHE_METADATA_CLASS
+				}),
+				worker: options.worker,
+				exportName: CACHE_METADATA_CLASS
+			}
+		}
+	};
+}
+async function createWorkersResponseStoreSelfContainedConfig(options) {
+	const { bindings } = await import("@cloudflare/vite-plugin/experimental-config");
+	const storage = await createResponseStoreWorkerConfig(options);
+	return {
+		...storage,
+		env: {
+			...storage.env,
+			[DEFAULT_VERSION_METADATA_BINDING]: bindings.versionMetadata()
+		}
+	};
+}
+async function createWorkersResponseStoreServiceBindingConfig(options) {
+	const { bindings } = await import("@cloudflare/vite-plugin/experimental-config");
+	const storage = await createResponseStoreWorkerConfig({
+		worker: options.worker.name,
+		bucket: options.bucket
+	});
+	const serviceBindingWorker = {
+		...options.worker,
+		entrypoint: RESPONSE_STORE_SERVICE_ENTRYPOINT,
+		workersDev: false,
+		previewUrls: false,
+		...storage
+	};
+	return {
+		accountId: options.accountId,
+		serviceBindingWorker,
+		applicationWorker: {
+			cache: { enabled: false },
+			env: {
+				[RESPONSE_STORE_BINDING]: bindings.worker({
+					worker: serviceBindingWorker,
+					exportName: RESPONSE_STORE_ENTRYPOINT
+				}),
+				[DEFAULT_VERSION_METADATA_BINDING]: bindings.versionMetadata()
+			}
+		}
+	};
+}
+async function createWorkersCacheConfig({ versionMetadataBinding = DEFAULT_VERSION_METADATA_BINDING } = {}) {
+	if (versionMetadataBinding.length === 0) throw new TypeError("versionMetadataBinding must be a non-empty string");
+	const { bindings, exports } = await import("@cloudflare/vite-plugin/experimental-config");
+	return {
+		cache: { enabled: false },
+		env: { [versionMetadataBinding]: bindings.versionMetadata() },
+		exports: {
+			VinextCachedResponse: exports.worker({ cache: { enabled: true } }),
+			VinextUncachedResponse: exports.worker({ cache: { enabled: false } })
+		}
+	};
+}
+//#endregion
+export { createWorkersCacheConfig, createWorkersResponseStoreSelfContainedConfig, createWorkersResponseStoreServiceBindingConfig };

package/dist/cacheability-artifact.d.ts

@@ -1,9 +1,10 @@
 import { CacheabilityManifest } from "vinext/internal/server/cacheability-manifest";
 //#region src/cacheability-artifact.d.ts
+export type CloudflareDeploymentTool = "cf" | "wrangler";
 /**
  * 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;
+export declare function writeCacheabilityManifestArtifact(root: string, configuredPath: string | undefined, manifest: CacheabilityManifest, deploymentTool?: CloudflareDeploymentTool): string;
 //#endregion

package/dist/cacheability-artifact.js

@@ -115,16 +115,12 @@ function hasStaticModuleSpecifier(source, expected) {
 	}
 	return false;
 }
-function resolveGeneratedServerConfig(root, configuredPath) {
+function resolveGeneratedWranglerArtifact(root, configuredPath) {
 	const distDirectory = path.join(root, "dist");
 	const configPath = path.resolve(root, configuredPath ?? "dist/server/wrangler.json");
 	const relativeConfigPath = path.relative(distDirectory, configPath);
 	if (relativeConfigPath.startsWith("..") || path.isAbsolute(relativeConfigPath)) throw new Error("Two-stage CDN warming requires a generated Wrangler config under dist/. Pass --config dist/server/wrangler.json (or another generated dist config).");
 	if (!fs.existsSync(configPath) || !fs.lstatSync(configPath).isFile()) throw new Error(`Two-stage CDN warming requires the generated Wrangler config at ${path.relative(root, configPath)}. Rebuild the app before deploying.`);
-	return configPath;
-}
-function assertManifestModuleReachable(configPath) {
-	const serverDirectory = path.dirname(configPath);
 	let config;
 	try {
 		config = JSON.parse(fs.readFileSync(configPath, "utf8"));
@@ -133,8 +129,36 @@ function assertManifestModuleReachable(configPath) {
 	}
 	const main = config && typeof config === "object" && !Array.isArray(config) ? config.main : void 0;
 	if (typeof main !== "string" || main.length === 0) throw new Error("Two-stage CDN warming requires a generated Wrangler main module.");
+	return {
+		configPath,
+		main,
+		serverDirectory: path.dirname(configPath)
+	};
+}
+function resolveBuildOutputArtifact(root) {
+	const outputDirectory = path.join(root, ".cloudflare", "output");
+	const configPaths = fs.existsSync(outputDirectory) ? fs.readdirSync(outputDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(outputDirectory, entry.name, "workers", "default", "worker.config.json")).filter((candidate) => fs.existsSync(candidate) && fs.lstatSync(candidate).isFile()) : [];
+	if (configPaths.length !== 1) throw new Error("Two-stage CDN warming requires one default Worker Build Output config under .cloudflare/output/. Rebuild the app before deploying.");
+	const configPath = configPaths[0];
+	let config;
+	try {
+		config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+	} catch (cause) {
+		throw new Error("Two-stage CDN warming could not parse the generated Build Output config.", { cause });
+	}
+	const manifest = config && typeof config === "object" && !Array.isArray(config) ? config.manifest : void 0;
+	const main = manifest && typeof manifest === "object" && !Array.isArray(manifest) ? manifest.mainModule : void 0;
+	if (typeof main !== "string" || main.length === 0) throw new Error("Two-stage CDN warming requires a generated Build Output main module.");
+	return {
+		configPath,
+		main,
+		serverDirectory: path.join(path.dirname(configPath), "bundle")
+	};
+}
+function assertManifestModuleReachable(artifact) {
+	const { main, serverDirectory } = artifact;
 	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 (!fs.existsSync(mainPath) || !fs.lstatSync(mainPath).isFile()) throw new Error("Two-stage CDN warming could not find the generated Worker main module.");
 	const viteManifestPath = path.join(serverDirectory, ".vite", "manifest.json");
 	let viteManifest;
 	try {
@@ -168,10 +192,10 @@ function assertManifestModuleReachable(configPath) {
 * The application build already imports this stable module asset, so the
 * completed dist directory remains the exact input to the final upload.
 */
-function writeCacheabilityManifestArtifact(root, configuredPath, manifest) {
-	const configPath = resolveGeneratedServerConfig(root, configuredPath);
-	assertManifestModuleReachable(configPath);
-	const serverDirectory = path.dirname(configPath);
+function writeCacheabilityManifestArtifact(root, configuredPath, manifest, deploymentTool = "wrangler") {
+	const artifact = deploymentTool === "cf" ? resolveBuildOutputArtifact(root) : resolveGeneratedWranglerArtifact(root, configuredPath);
+	assertManifestModuleReachable(artifact);
+	const { configPath, serverDirectory } = artifact;
 	const manifestPath = path.join(serverDirectory, CACHEABILITY_MANIFEST_MODULE);
 	if (!fs.existsSync(manifestPath) || !fs.lstatSync(manifestPath).isFile()) throw new Error(`Two-stage CDN warming requires ${CACHEABILITY_MANIFEST_MODULE} in the generated Worker artifact. Rebuild the app before deploying.`);
 	const serializedManifest = JSON.stringify(manifest);

package/dist/deploy-config.d.ts

@@ -52,6 +52,7 @@ export declare function workerEntryHasCacheHandler(root: string): boolean;
  */
 export declare function formatMissingCacheAdapterError(options: {
   configFile?: string;
+  typedConfig?: boolean;
 }): string;
-export declare function formatImageOptimizationHint(): string;
+export declare function formatImageOptimizationHint(typedConfig?: boolean): string;
 //#endregion

package/dist/deploy-config.js

@@ -178,9 +178,10 @@ function workerEntryHasCacheHandler(root) {
 */
 function formatMissingCacheAdapterError(options) {
 	const configRef = options.configFile ? options.configFile : "your Vite config";
-	return `[vinext] This app uses ISR / caching but no cache adapter is configured in ${configRef}.\n\n  Production deployments need a persistent cache backend. Declare one on the\n  vinext() plugin in ${configRef}:\n\n    import { kvDataAdapter } from "@vinext/cloudflare/cache/kv-data-adapter";\n\n    export default defineConfig({\n      plugins: [\n        vinext({\n          cache: {\n            data: kvDataAdapter(), // KV-backed data cache (binding: VINEXT_KV_CACHE)\n          },\n        }),\n        cloudflare(),\n      ],\n    });\n\n  The VINEXT_KV_CACHE namespace binding is added to wrangler.jsonc for you.\n  Create the namespace with:\n\n    npx wrangler kv namespace create VINEXT_KV_CACHE`;
+	return `[vinext] This app uses ISR / caching but no cache adapter is configured in ${configRef}.\n\n  Production deployments need a persistent cache backend. Declare one on the\n  vinext() plugin in ${configRef}:\n\n    import { kvDataAdapter } from "@vinext/cloudflare/cache/kv-data-adapter";\n\n    export default defineConfig({\n      plugins: [\n        vinext({\n          cache: {\n            data: kvDataAdapter(), // KV-backed data cache (binding: VINEXT_KV_CACHE)\n          },\n        }),\n        cloudflare(),\n      ],\n    });\n\n` + (options.typedConfig ? `  Configure the VINEXT_KV_CACHE namespace binding in cloudflare.config.ts.` : "  The VINEXT_KV_CACHE namespace binding is added to wrangler.jsonc for you.\n  Create the namespace with:\n\n    npx wrangler kv namespace create VINEXT_KV_CACHE");
 }
-function formatImageOptimizationHint() {
+function formatImageOptimizationHint(typedConfig = false) {
+	if (typedConfig) return "  [vinext] next/image is served unoptimized. To enable edge image\n  optimization via Cloudflare Images, configure imagesOptimizer() in your\n  Vite config and the IMAGES binding in cloudflare.config.ts.";
 	return "  [vinext] next/image is served unoptimized. To enable edge image\n  optimization via Cloudflare Images, run:\n\n    vinext init --platform=cloudflare --image-optimization=cloudflare-images\n\n  This adds the imagesOptimizer() option to your Vite config and the matching\n  IMAGES binding to your Wrangler config without replacing existing settings.";
 }
 //#endregion

package/dist/deploy-help.js

@@ -9,16 +9,16 @@ function formatDeployHelp() {
     - Detects App Router or Pages Router
     - Validates setup from vinext init --platform=cloudflare
     - Builds the project with Vite
-    - Deploys via wrangler
+    - Deploys with cf for typed Cloudflare config projects, or Wrangler otherwise
 
   Options:
     --preview                Deploy to preview environment (same as --env preview)
-    --env <name>             Deploy using wrangler env.<name>
-    --name <name>            Custom Worker name (default: from package.json)
+    --env <name>             Cloudflare mode for typed config; Wrangler environment otherwise
+    --name <name>            Custom Worker name for Wrangler config projects
     --config <path>          Wrangler config path (default: wrangler.jsonc/json/toml)
     --skip-build             Skip the build step (use existing dist/)
     --dry-run                Validate setup without building or deploying
-    --verbose                Print raw output from internal Wrangler commands
+    --verbose                Print raw output from internal Cloudflare CLI commands
     --no-promote             Do not promote the uploaded Worker version to 100%
                              traffic
     --prerender-all          Pre-render discovered routes after building (future
@@ -91,7 +91,7 @@ function formatDeployHelp() {
     vpx @vinext/cloudflare deploy                                      Build and deploy with Vite+
     vp exec vinext-cloudflare deploy                                   Run the locally installed Vite+ bin
     vinext-cloudflare deploy --preview                                 Deploy to a preview URL
-    vinext-cloudflare deploy --env staging                             Deploy using wrangler env.staging
+    vinext-cloudflare deploy --env staging                             Deploy using Cloudflare mode/environment staging
     vinext-cloudflare deploy --config dist/server/wrangler.json        Deploy using a generated Wrangler config
     vinext-cloudflare deploy --dry-run                                 Validate setup without building or deploying
     vinext-cloudflare deploy --name my-app                             Deploy with a custom Worker name