@vinext/cloudflare 1.0.0-beta.8 → 1.0.0

package/dist/cdn-warm.js

@@ -38,7 +38,7 @@ function readPrerenderPathManifest(manifestPath) {
 		const parsed = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
 		if (!parsed || typeof parsed !== "object") return null;
 		const manifest = parsed;
-		if (!Array.isArray(manifest.paths) || !manifest.paths.every((pathname) => typeof pathname === "string") || manifest.appPaths !== void 0 && (!Array.isArray(manifest.appPaths) || !manifest.appPaths.every((pathname) => typeof pathname === "string")) || manifest.pagesPaths !== void 0 && (!Array.isArray(manifest.pagesPaths) || !manifest.pagesPaths.every((pathname) => typeof pathname === "string")) || manifest.pagesDataPaths !== void 0 && (!Array.isArray(manifest.pagesDataPaths) || !manifest.pagesDataPaths.every((pathname) => typeof pathname === "string")) || manifest.excludedWarmPaths !== void 0 && (!Array.isArray(manifest.excludedWarmPaths) || !manifest.excludedWarmPaths.every((pathname) => typeof pathname === "string")) || manifest.fallbackRoutePatterns !== void 0 && (!Array.isArray(manifest.fallbackRoutePatterns) || !manifest.fallbackRoutePatterns.every((route) => route !== null && typeof route === "object" && !Array.isArray(route) && (route.kind === "app-page" || route.kind === "app-route" || route.kind === "pages-page") && typeof route.pattern === "string" && route.pattern.startsWith("/"))) || manifest.rscPaths !== void 0 && (!Array.isArray(manifest.rscPaths) || !manifest.rscPaths.every((pathname) => typeof pathname === "string")) || manifest.routeHandlerPaths !== void 0 && (!Array.isArray(manifest.routeHandlerPaths) || !manifest.routeHandlerPaths.every((pathname) => typeof pathname === "string")) || manifest.routePatterns !== void 0 && (!manifest.routePatterns || typeof manifest.routePatterns !== "object" || Array.isArray(manifest.routePatterns) || !Object.entries(manifest.routePatterns).every(([pathname, route]) => pathname.startsWith("/") && route !== null && typeof route === "object" && !Array.isArray(route) && (route.kind === "app-page" || route.kind === "app-route" || route.kind === "pages-page") && typeof route.pattern === "string" && route.pattern.startsWith("/") && (route.cacheabilityProbe === void 0 || route.cacheabilityProbe !== null && typeof route.cacheabilityProbe === "object" && !Array.isArray(route.cacheabilityProbe) && typeof route.cacheabilityProbe.canPrunePattern === "boolean" && (route.cacheabilityProbe.concretePathname === void 0 || typeof route.cacheabilityProbe.concretePathname === "string" && route.cacheabilityProbe.concretePathname.startsWith("/")) && (route.cacheabilityProbe.routeMayResolve === void 0 || typeof route.cacheabilityProbe.routeMayResolve === "boolean") && (route.cacheabilityProbe.requestStageMayTerminate === void 0 || typeof route.cacheabilityProbe.requestStageMayTerminate === "boolean")))) || manifest.loadingShellPaths !== void 0 && (!Array.isArray(manifest.loadingShellPaths) || !manifest.loadingShellPaths.every((pathname) => typeof pathname === "string")) || manifest.basePath !== void 0 && typeof manifest.basePath !== "string" || manifest.buildIdentity !== void 0 && typeof manifest.buildIdentity !== "string" || manifest.deploymentId !== void 0 && typeof manifest.deploymentId !== "string" || manifest.rscBuildId !== void 0 && typeof manifest.rscBuildId !== "string" || manifest.trailingSlash !== void 0 && typeof manifest.trailingSlash !== "boolean" || manifest.responseVary !== void 0 && manifest.responseVary !== "verbatim") return null;
+		if (!Array.isArray(manifest.paths) || !manifest.paths.every((pathname) => typeof pathname === "string") || manifest.appPaths !== void 0 && (!Array.isArray(manifest.appPaths) || !manifest.appPaths.every((pathname) => typeof pathname === "string")) || manifest.pagesPaths !== void 0 && (!Array.isArray(manifest.pagesPaths) || !manifest.pagesPaths.every((pathname) => typeof pathname === "string")) || manifest.pagesDataPaths !== void 0 && (!Array.isArray(manifest.pagesDataPaths) || !manifest.pagesDataPaths.every((pathname) => typeof pathname === "string")) || manifest.excludedWarmPaths !== void 0 && (!Array.isArray(manifest.excludedWarmPaths) || !manifest.excludedWarmPaths.every((pathname) => typeof pathname === "string")) || manifest.fallbackRoutePatterns !== void 0 && (!Array.isArray(manifest.fallbackRoutePatterns) || !manifest.fallbackRoutePatterns.every((route) => route !== null && typeof route === "object" && !Array.isArray(route) && (route.kind === "app-page" || route.kind === "app-route" || route.kind === "pages-page") && typeof route.pattern === "string" && route.pattern.startsWith("/"))) || manifest.rscPaths !== void 0 && (!Array.isArray(manifest.rscPaths) || !manifest.rscPaths.every((pathname) => typeof pathname === "string")) || manifest.routeHandlerPaths !== void 0 && (!Array.isArray(manifest.routeHandlerPaths) || !manifest.routeHandlerPaths.every((pathname) => typeof pathname === "string")) || manifest.routePatterns !== void 0 && (!manifest.routePatterns || typeof manifest.routePatterns !== "object" || Array.isArray(manifest.routePatterns) || !Object.entries(manifest.routePatterns).every(([pathname, route]) => pathname.startsWith("/") && route !== null && typeof route === "object" && !Array.isArray(route) && (route.kind === "app-page" || route.kind === "app-route" || route.kind === "pages-page") && typeof route.pattern === "string" && route.pattern.startsWith("/") && (route.cacheabilityProbe === void 0 || route.cacheabilityProbe !== null && typeof route.cacheabilityProbe === "object" && !Array.isArray(route.cacheabilityProbe) && typeof route.cacheabilityProbe.canPrunePattern === "boolean" && (route.cacheabilityProbe.concretePathname === void 0 || typeof route.cacheabilityProbe.concretePathname === "string" && route.cacheabilityProbe.concretePathname.startsWith("/")) && (route.cacheabilityProbe.routeMayResolve === void 0 || typeof route.cacheabilityProbe.routeMayResolve === "boolean") && (route.cacheabilityProbe.requestStageMayTerminate === void 0 || typeof route.cacheabilityProbe.requestStageMayTerminate === "boolean") && (route.cacheabilityProbe.unlisted === void 0 || typeof route.cacheabilityProbe.unlisted === "boolean")))) || manifest.loadingShellPaths !== void 0 && (!Array.isArray(manifest.loadingShellPaths) || !manifest.loadingShellPaths.every((pathname) => typeof pathname === "string")) || manifest.loadingBoundaryRoutePatterns !== void 0 && (!Array.isArray(manifest.loadingBoundaryRoutePatterns) || !manifest.loadingBoundaryRoutePatterns.every((pattern) => typeof pattern === "string" && pattern.startsWith("/"))) || manifest.basePath !== void 0 && typeof manifest.basePath !== "string" || manifest.buildIdentity !== void 0 && typeof manifest.buildIdentity !== "string" || manifest.deploymentId !== void 0 && typeof manifest.deploymentId !== "string" || manifest.rscBuildId !== void 0 && typeof manifest.rscBuildId !== "string" || manifest.trailingSlash !== void 0 && typeof manifest.trailingSlash !== "boolean" || manifest.responseVary !== void 0 && manifest.responseVary !== "verbatim") return null;
 		return manifest;
 	} catch (error) {
 		console.warn(`[vinext] Failed to read prerender path manifest at ${manifestPath}:`, error);
@@ -90,6 +90,7 @@ function createPrerenderWarmPlan(root, manifest, options) {
 		...manifest.buildIdentity ? { buildIdentity: manifest.buildIdentity } : {},
 		...manifest.deploymentId ? { deploymentId: manifest.deploymentId } : {},
 		...manifest.fallbackRoutePatterns ? { fallbackRoutePatterns: manifest.fallbackRoutePatterns } : {},
+		...manifest.loadingBoundaryRoutePatterns ? { loadingBoundaryRoutePatterns: manifest.loadingBoundaryRoutePatterns } : {},
 		loadingShellPaths: supportsCanonicalRsc ? (manifest.loadingShellPaths ?? []).map(applyConfig) : [],
 		...manifest.pagesDataPaths ? { pagesDataPaths: manifest.pagesDataPaths } : {},
 		...manifest.pagesPaths ? { pagesPaths: manifest.pagesPaths.map(applyConfig) } : {},
@@ -365,6 +366,7 @@ const REUSABLE_CF_CACHE_STATUSES = /* @__PURE__ */ new Set([
 	"REVALIDATED",
 	"UPDATING"
 ]);
+const TRANSITIONAL_VINEXT_CACHE_STATUSES = /* @__PURE__ */ new Set(["MISS", "UPDATING"]);
 const NON_CACHEABLE_CF_CACHE_STATUSES = /* @__PURE__ */ new Set(["BYPASS"]);
 const CDN_CACHE_POLICY_HEADERS = [
 	"Cloudflare-CDN-Cache-Control",
@@ -445,20 +447,29 @@ function validateCachePolicy(response, requireCacheStatus, requireCacheHit = fal
 		error: `CF-Cache-Status is ${cacheStatus}`
 	};
 }
-function validateVinextCacheStatus(response) {
+function validateVinextCacheStatus(response, missingStatus = "failed", requireCacheHit = false) {
 	const status = response.headers.get(VINEXT_CACHE_HEADER)?.trim().toUpperCase();
+	if (requireCacheHit && status !== "HIT") return {
+		outcome: "failed",
+		error: `${VINEXT_CACHE_HEADER} is ${status ?? "missing"}; the cache fill is not reusable`
+	};
 	if (status === "MISS" || status === "HIT" || status === "UPDATING") return { outcome: "warmed" };
 	if (status === "BYPASS" || status === "DYNAMIC") return {
 		outcome: "skipped",
 		reason: `${VINEXT_CACHE_HEADER} is ${status}`
 	};
-	return {
+	return missingStatus === "skipped" ? {
+		outcome: "skipped",
+		reason: `response is missing ${VINEXT_CACHE_HEADER}`
+	} : {
 		outcome: "failed",
 		error: `response is missing ${VINEXT_CACHE_HEADER}`
 	};
 }
 function validateWarmAdmission(response, statusSource, requireCacheHit) {
-	return statusSource === "vinext" ? validateVinextCacheStatus(response) : validateCachePolicy(response, true, requireCacheHit);
+	if (statusSource === "vinext") return validateVinextCacheStatus(response, "failed", requireCacheHit);
+	if (statusSource === "data-cache") return validateVinextCacheStatus(response, "skipped", requireCacheHit);
+	return validateCachePolicy(response, true, requireCacheHit);
 }
 function validateBuildIdentity(response, expectedBuildId) {
 	if (expectedBuildId !== void 0 && response.headers.get("X-Vinext-Build-Id") !== expectedBuildId) {
@@ -645,6 +656,14 @@ function shouldRetryValidationFailure(response, target, options) {
 	if (expectedIdentities.some((matches) => !matches)) return true;
 	return isRetryableStatus(response.status, options.retryNotFound);
 }
+function isRetryableCertificationFailure(response, statusSource, retryPropagationFailures) {
+	if (statusSource === "cloudflare") {
+		const status = response.headers.get("CF-Cache-Status")?.trim().toUpperCase();
+		return !REUSABLE_CF_CACHE_STATUSES.has(status ?? "") && (retryPropagationFailures || ADMITTED_CF_CACHE_STATUSES.has(status ?? ""));
+	}
+	const status = response.headers.get(VINEXT_CACHE_HEADER)?.trim().toUpperCase();
+	return TRANSITIONAL_VINEXT_CACHE_STATUSES.has(status ?? "");
+}
 async function warmOnePath(target, options) {
 	const url = buildWarmupUrl(options.targetUrl, target.pathname);
 	let lastError = "request failed before the first attempt";
@@ -707,8 +726,7 @@ async function warmOnePath(target, options) {
 				}
 				lastSkippedReason = null;
 				lastError = validation.error;
-				const cacheStatus = response.headers.get("CF-Cache-Status")?.trim().toUpperCase();
-				lastRetryable = options.requireCacheHit && ADMITTED_CF_CACHE_STATUSES.has(cacheStatus ?? "") && !REUSABLE_CF_CACHE_STATUSES.has(cacheStatus ?? "") || shouldRetryValidationFailure(response, target, options);
+				lastRetryable = options.requireCacheHit && isRetryableCertificationFailure(response, options.statusSource, options.retryPropagationFailures) || shouldRetryValidationFailure(response, target, options);
 				if (!lastRetryable) break;
 				if (!canRetry(attempt)) break;
 				if (!await waitBeforeRetry()) return {
@@ -745,8 +763,7 @@ async function warmOnePath(target, options) {
 			}
 			lastSkippedReason = null;
 			lastError = validation.error;
-			const cacheStatus = response.headers.get("CF-Cache-Status")?.trim().toUpperCase();
-			lastRetryable = options.requireCacheHit && ADMITTED_CF_CACHE_STATUSES.has(cacheStatus ?? "") && !REUSABLE_CF_CACHE_STATUSES.has(cacheStatus ?? "") || shouldRetryValidationFailure(response, target, options);
+			lastRetryable = options.requireCacheHit && isRetryableCertificationFailure(response, options.statusSource, options.retryPropagationFailures) || shouldRetryValidationFailure(response, target, options);
 			if (!lastRetryable) break;
 		} catch (error) {
 			lastSkippedReason = null;

package/dist/deploy-config.d.ts

@@ -1,4 +1,4 @@
-import { VinextCacheConfig } from "vinext/internal/cache-adapters";
+import { VinextCacheConfig } from "vinext/internal/config/prerender";
 //#region src/deploy-config.d.ts
 /**
  * Check whether an existing vite.config file already imports and uses the
@@ -18,16 +18,10 @@ export declare function viteConfigHasCloudflarePlugin(root: string): boolean;
  * blocked on a false negative.
  */
 export declare function viteConfigHasCacheAdapter(root: string): boolean;
-export type ResolvedKvDataAdapterConfig = {
-  binding: string;
-  appPrefix?: string;
-  ttlSeconds?: number;
-};
 export type ResolvedCdnAdapterConfig = {
   versionMetadataBinding: string;
 };
 export declare function resolveCdnAdapterConfig(cache: VinextCacheConfig | null | undefined): ResolvedCdnAdapterConfig | null;
-export declare function resolveKvDataAdapterConfig(cache: VinextCacheConfig | null | undefined): ResolvedKvDataAdapterConfig | null;
 export declare function viteConfigHasImageAdapter(root: string): boolean;
 /**
  * Detect whether an existing user-authored Worker entry wires up a cache
@@ -52,6 +46,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

@@ -1,5 +1,4 @@
-import { DEFAULT_KV_DATA_CACHE_BINDING } from "./cache/kv-data-adapter.js";
-import { DEFAULT_CDN_VERSION_METADATA_BINDING } from "./cache/cdn-adapter.js";
+import { DEFAULT_CDN_VERSION_METADATA_BINDING } from "./cache/workers-cache-cdn-adapter.js";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -105,24 +104,6 @@ function resolveCdnAdapterConfig(cache) {
 	const options = cdn.options;
 	return { versionMetadataBinding: typeof options?.versionMetadataBinding === "string" && options.versionMetadataBinding.length > 0 ? options.versionMetadataBinding : DEFAULT_CDN_VERSION_METADATA_BINDING };
 }
-function isCloudflareKvDataAdapterPath(adapter) {
-	const normalized = adapter.replace(/\\/g, "/");
-	return normalized === "@vinext/cloudflare/cache/kv-data-adapter.runtime" || normalized === "@vinext/cloudflare/cache/kv-data-adapter.runtime.js" || normalized.endsWith("/cache/kv-data-adapter.runtime.js");
-}
-function readPositiveNumberOption(options, field) {
-	const value = options?.[field];
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
-}
-function resolveKvDataAdapterConfig(cache) {
-	const data = cache?.data;
-	if (!data?.adapter || !isCloudflareKvDataAdapterPath(data.adapter)) return null;
-	const options = data.options;
-	return {
-		binding: typeof options?.binding === "string" && options.binding.length > 0 ? options.binding : DEFAULT_KV_DATA_CACHE_BINDING,
-		...typeof options?.appPrefix === "string" && options.appPrefix.length > 0 ? { appPrefix: options.appPrefix } : {},
-		...readPositiveNumberOption(options, "ttlSeconds") !== void 0 ? { ttlSeconds: readPositiveNumberOption(options, "ttlSeconds") } : {}
-	};
-}
 function viteConfigHasImageAdapter(root) {
 	const configPath = findViteConfigPath(root);
 	if (!configPath) return true;
@@ -178,10 +159,11 @@ 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
-export { formatImageOptimizationHint, formatMissingCacheAdapterError, resolveCdnAdapterConfig, resolveKvDataAdapterConfig, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler };
+export { formatImageOptimizationHint, formatMissingCacheAdapterError, resolveCdnAdapterConfig, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler };

package/dist/deploy-help.js

@@ -9,76 +9,81 @@ 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
-    --prerender-all          Pre-render discovered routes after building (future
-                             releases will auto-populate the remote cache)
+    --verbose                Print raw output from internal Cloudflare CLI commands
+    --no-promote             Do not promote the uploaded Worker version to 100%
+                             traffic
+    --prerender-all          Deprecated for Worker deployments; use
+                             --warm-cache instead (still honored for static
+                             export and cache adapters that package local
+                             prerender output)
     --prerender-concurrency <count>
-                             Maximum number of routes to pre-render in parallel
-    --experimental-warm-cdn-cache
-                             Upload a Worker version, warm build-discovered paths
-                             through the production URL, then promote it (experimental)
-    --warm-cdn-target <origin>
+                             Maximum parallel routes for local prerendering
+    --warm-cache             Upload a Worker version, warm build-discovered paths
+                             through the production URL, then promote it
+    --warm-cache-target <origin>
                              HTTPS origin to use for discovery, probing, and warming
                              (overrides URLs inferred from Wrangler output)
-    --warm-cdn-concurrency <count>
+                             Also supported with traffic-aware warming
+    --warm-cache-concurrency <count>
                              Maximum number of CDN warmup requests in parallel (default: 25)
-    --warm-cdn-timeout <ms>  Per-request CDN warmup timeout (default: 10000)
-    --warm-cdn-retries <n>   Retries per failed CDN warmup request (default: 1;
+    --warm-cache-timeout <ms>  Per-request CDN warmup timeout (default: 10000)
+    --warm-cache-retries <n>   Retries per failed CDN warmup request (default: 1;
                              staged-version propagation default: 60)
-    --warm-cdn-discovery-timeout <ms>
+    --warm-cache-discovery-timeout <ms>
                              Total staged path-discovery deadline (default: 120000)
-    --warm-cdn-discovery-retries <n>
+    --warm-cache-discovery-retries <n>
                              Optional staged path-discovery retry limit
                              (default: derived from the discovery deadline)
-    --warm-cdn-probe-timeout <ms>
+    --warm-cache-probe-timeout <ms>
                              Abort when cacheability probing makes no progress for
                              this duration (default: 120000)
-    --warm-cdn-probe-retries <n>
+    --warm-cache-probe-retries <n>
                              Cacheability-probe retries (default: 2)
-    --warm-cdn-certify      With --experimental-warm-cdn-cache, re-request warmed
-                             entries using headers only and require every planned
-                             entry to be reusable before promotion
-    --warm-cdn-readiness-timeout <ms>
+    --warm-cache-certify      With either warming mode, re-request warmed
+                             entries using headers only and require reusable hits.
+                             Traffic-aware warming requires every selected entry
+                             to be reusable before promotion
+    --warm-cache-readiness-timeout <ms>
                              Explicit total staged-readiness deadline (default:
                              120000)
-    --warm-cdn-readiness-retries <n>
+    --warm-cache-readiness-retries <n>
                              Staged-readiness retries (default: 60)
-    --warm-cdn-readiness-probes <count>
+    --warm-cache-readiness-probes <count>
                              Consecutive successful staged-readiness probes
                              required before warming (default: 6)
-    --warm-cdn-readiness-probe-delay <ms>
+    --warm-cache-readiness-probe-delay <ms>
                              Delay between staged-readiness probes (default: 1000)
-    --dangerously-promote-on-cdn-warm-error
+    --dangerously-promote-on-warm-cache-error
                              Promote even when ordinary staged warmup cannot be
-                             verified (never bypasses --warm-cdn-certify)
-    --warm-cdn-no-promote    Leave the warmed Worker version staged at 0% traffic;
-                             production triggers are still applied before warming
-    --warm-cdn-promotion-delay <ms>
+                             verified (never bypasses --warm-cache-certify)
+    --warm-cache-promotion-delay <ms>
                              Delay before promotion after warmup (default: 15000)
-    --warm-cdn-include-fallbacks
+    --warm-cache-include-fallbacks
                              Also warm PPR fallback-shell placeholder paths
     -h, --help               Show this help
 
-  Experimental:
-    --experimental-tpr               Enable Traffic-aware Pre-Rendering
-    --tpr-coverage <pct>             Traffic coverage target, 0-100 (default: 90)
-    --tpr-limit <count>              Hard cap on pages to pre-render (default: 1000)
-    --tpr-window <hours>             Analytics lookback window in hours (default: 24)
+  Traffic-aware warming:
+    --traffic-aware-warm-cache       Select cache warming routes from traffic
+    --traffic-aware-coverage <pct>   Traffic coverage target, 0-100 (default: 90)
+    --traffic-aware-limit <count>    Hard cap on selected routes (default: 1000)
+    --traffic-aware-window <hours>   Analytics lookback window in hours (default: 24)
 
-  TPR (Traffic-aware Pre-Rendering) uses Cloudflare zone analytics to determine
-  which pages get the most traffic and pre-renders them into KV cache during
-  deploy. This feature is experimental and must be explicitly enabled. Requires
-  a custom domain (zone analytics are unavailable on *.workers.dev) and the
-  CLOUDFLARE_API_TOKEN environment variable with Zone.Analytics read permission.
+  Traffic-aware warming uses Cloudflare zone analytics to select the
+  highest-traffic routes, then feeds those routes into the same staged CDN
+  pre-warming flow used by --warm-cache. It requires a custom
+  domain and a CLOUDFLARE_API_TOKEN with Zone > Analytics > Read and
+  Zone > Zone > Read permissions for that zone.
+  Use --warm-cache-target <origin> to provide the production HTTPS origin
+  manually for traffic-aware analytics selection, discovery, probing, and warming.
 
   Workers Cache automatically uses tiered caching. Warmed entries can therefore
   be reused outside the data center reached by the warmup request after cache
@@ -89,16 +94,22 @@ 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
-    vinext-cloudflare deploy --experimental-warm-cdn-cache              Warm build-discovered paths during version deploy (experimental)
-    vinext-cloudflare deploy --experimental-warm-cdn-cache --warm-cdn-target https://example.com
+    vinext-cloudflare deploy --no-promote                              Upload a version without changing deployment traffic
+    vinext-cloudflare deploy --warm-cache                               Warm build-discovered paths during version deploy
+    vinext-cloudflare deploy --warm-cache --warm-cache-target https://example.com
                                                                           Warm an explicit production origin
-    vinext-cloudflare deploy --experimental-tpr                        Enable TPR during deploy
-    vinext-cloudflare deploy --experimental-tpr --tpr-coverage 95      Cover 95% of traffic
-    vinext-cloudflare deploy --experimental-tpr --tpr-limit 500        Cap at 500 pages
+    vinext-cloudflare deploy --traffic-aware-warm-cache
+                                                                          Enable traffic-aware warming
+    vinext-cloudflare deploy --traffic-aware-warm-cache --traffic-aware-coverage 95
+                                                                          Cover 95% of traffic
+    vinext-cloudflare deploy --traffic-aware-warm-cache --traffic-aware-limit 500
+                                                                          Cap at 500 routes
+    vinext-cloudflare deploy --traffic-aware-warm-cache --warm-cache-target https://example.com
+                                                                          Select and warm traffic routes for an explicit origin
 `;
 }
 function printDeployHelp() {

package/dist/deploy.d.ts

@@ -1,9 +1,9 @@
 import { CdnWarmOptions, CdnWarmRequestPlan, PrerenderWarmPlan } from "./cdn-warm.js";
-import { parseWranglerConfig } from "./tpr.js";
-import { WranglerDeploymentStatus, WranglerVersionTraffic } from "./version-deploy.js";
-import { KVBulkPair } from "./prerender-kv-populate.js";
+import { parseWranglerConfig } from "./wrangler-config.js";
+import { TrafficEntry } from "./tpr.js";
+import { WranglerDeploymentStatus, WranglerVersionTraffic, WranglerVersionUploadResult } from "./version-deploy.js";
 import { spawn } from "node:child_process";
-import { VinextCacheConfig } from "vinext/internal/config/prerender";
+import { VinextCacheConfig, VinextRouteRootConfig } from "vinext/internal/config/prerender";
 import { ProjectInfo } from "vinext/internal/utils/project";
 //#region src/deploy.d.ts
 export declare const DEFAULT_CDN_WARM_PROMOTION_DELAY_MS = 15000;
@@ -58,21 +58,24 @@ export type DeployOptions = {
   warmCdnReadinessProbeDelay?: number;
   /** Promote even when staged CDN warmup cannot be completed */
   dangerouslyPromoteOnCdnWarmError?: boolean;
-  /** Promote the warmed Worker version to 100% traffic (default: true) */
+  /** Promote the uploaded Worker version to 100% traffic (default: true) */
   warmCdnPromote?: boolean;
   /** Delay between successful warmup and promotion in milliseconds */
   warmCdnPromotionDelay?: number;
   /** Include PPR fallback-shell placeholder paths during CDN warmup */
   warmCdnIncludeFallbacks?: boolean;
-  /** Enable experimental TPR (Traffic-aware Pre-Rendering) */
+  /** Select CDN pre-warm routes using traffic analytics */
   experimentalTPR?: boolean;
   /** TPR: traffic coverage percentage target (0–100, default: 90) */
   tprCoverage?: number;
-  /** TPR: hard cap on number of pages to pre-render (default: 1000) */
+  /** TPR: hard cap on selected routes (default: 1000) */
   tprLimit?: number;
   /** TPR: analytics lookback window in hours (default: 24) */
   tprWindow?: number;
 };
+export type DeploymentTool = "cf" | "wrangler";
+/** The typed cf Vite plugin emits Worker and asset bundles into Build Output. */
+export declare function resolvePrerenderOutputDirs(root: string, deploymentTool: DeploymentTool, configured: VinextRouteRootConfig | null): VinextRouteRootConfig | null;
 export declare function parseDeployArgs(args: string[]): {
   help: boolean;
   preview: boolean;
@@ -120,21 +123,20 @@ export declare function parseDeployArgs(args: string[]): {
  * Passing `undefined` is a no-op; the callback runs with `process.env` untouched.
  */
 export declare function withCloudflareEnv<T>(env: string | undefined, fn: () => Promise<T>): Promise<T>;
+export declare function resolveViteBuildMode(deploymentTool: DeploymentTool, env: string | undefined): string;
 type WranglerDeployArgs = {
   args: string[];
   env: string | undefined;
 };
-type WranglerKVBulkPutArgs = {
+type CfDeployArgs = {
   args: string[];
-  env: string | undefined;
+  mode: string | undefined;
 };
 export declare function validateWranglerEnvName(env: string): string;
 export declare function buildWranglerDeployArgs(options: Pick<DeployOptions, "preview" | "env" | "name" | "config">): WranglerDeployArgs;
-export declare function buildWranglerKVBulkPutArgs(options: {
-  binding: string;
-  env?: string;
-  filePath: string;
-}): WranglerKVBulkPutArgs;
+export declare function resolveDeploymentTool(root: string): DeploymentTool;
+export declare function isCfCliInstalled(root: string, resolvePackageJson?: (root: string) => string | null): boolean;
+export declare function buildCfDeployArgs(options: Pick<DeployOptions, "preview" | "env">): CfDeployArgs;
 /**
  * Resolve Wrangler's JavaScript CLI entrypoint in node_modules.
  *
@@ -142,6 +144,7 @@ export declare function buildWranglerKVBulkPutArgs(options: {
  * shim and command shell that package managers create on Windows.
  */
 export declare function resolveWranglerBin(root: string, resolvePackageJson?: (root: string) => string | null): string;
+export declare function resolveCfBin(root: string, resolvePackageJson?: (root: string) => string | null): string;
 export declare function buildNodeCliInvocation(scriptPath: string, args: string[], nodeExecutable?: string): {
   file: string;
   args: string[];
@@ -151,30 +154,37 @@ export declare function buildWranglerInvocation(root: string, options: Pick<Depl
   args: string[];
   env: string | undefined;
 };
-export declare function runWranglerKVBulkPut(root: string, options: {
-  binding: string;
-  env?: string;
-  pairs: KVBulkPair[];
-  tempDir?: string;
-}, execute?: typeof spawn, nodeExecutable?: string): Promise<void>;
-export declare function runWranglerDeploy(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config">, execute?: typeof spawn): Promise<string>;
+export declare function runWranglerDeploy(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose"> & {
+  promote?: boolean;
+}, execute?: typeof spawn): Promise<string>;
+export declare function runCfDeploy(root: string, options: Pick<DeployOptions, "preview" | "env">, execute?: typeof spawn): Promise<string>;
 export declare function hasCdnWarmRequests(plan: Omit<CdnWarmRequestPlan, "pagesDataPaths"> & {
   pagesDataPaths?: readonly string[];
 }): boolean;
+export declare function selectTPRWarmPlan(plan: PrerenderWarmPlan, traffic: readonly TrafficEntry[], coverage: number, limit: number): PrerenderWarmPlan;
 export declare function projectRequiresRouteCacheabilityProbeManifest(project: Pick<ProjectInfo, "isAppRouter" | "isPagesRouter">, cacheConfig: VinextCacheConfig | null): boolean;
 type CdnWarmDeployOptions = Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose" | "warmCdnTarget" | "warmCdnConcurrency" | "warmCdnTimeout" | "warmCdnRetries" | "warmCdnDiscoveryTimeout" | "warmCdnDiscoveryRetries" | "warmCdnProbeTimeout" | "warmCdnProbeRetries" | "warmCdnCertify" | "warmCdnReadinessTimeout" | "warmCdnReadinessRetries" | "warmCdnReadinessProbes" | "warmCdnReadinessProbeDelay" | "dangerouslyPromoteOnCdnWarmError" | "warmCdnPromote" | "warmCdnPromotionDelay"> & Pick<CdnWarmOptions, "deploymentId" | "expectedBuildId" | "expectedRscBuildId" | "loadingShellPaths" | "pagesDataPaths" | "routeHandlerPaths" | "routePatterns" | "rscPaths" | "statusSource"> & {
+  deploymentTool?: DeploymentTool;
+  /** Allow optional route selection to discover no warmable requests. */
+  allowEmptyWarmPlan?: boolean;
   /** Probe a staged Worker and upload the resulting manifest as a second version. */
   cacheabilityProbe?: boolean;
   discoverWarmPlan?: (target: {
     headers?: HeadersInit;
     targetUrl: string;
   }) => Promise<PrerenderWarmPlan>;
+  /** Narrow the final warm requests without changing discovery or probe metadata. */
+  selectWarmPlan?: (plan: PrerenderWarmPlan) => PrerenderWarmPlan;
+};
+type DeploymentControlPlaneOptions = Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose"> & {
+  deploymentTool?: DeploymentTool;
 };
 export declare function deployWithCdnWarmup(root: string, paths: readonly string[], options: CdnWarmDeployOptions): Promise<string>;
 export declare function resolveCdnWarmupTargetUrl(root: string, deployedUrl: string | null): string | null;
 export declare function resolveCdnWarmupTargetUrl(root: string, deployedUrl: string | null, options: Pick<DeployOptions, "preview" | "env" | "config" | "warmCdnTarget">): string | null;
 export declare function getZeroPercentStagingTraffic(deployment: WranglerDeploymentStatus | null, versionId: string): WranglerVersionTraffic[] | null;
 type ParsedWranglerConfig = NonNullable<ReturnType<typeof parseWranglerConfig>>;
+export declare function resolveDeploymentControlPlaneOptions(options: DeploymentControlPlaneOptions, upload: Pick<WranglerVersionUploadResult, "workerName">): DeploymentControlPlaneOptions;
 export declare function resolveWorkerNameForVersionOverride(config: ParsedWranglerConfig | null, options: Pick<DeployOptions, "preview" | "env" | "name">): string | undefined;
 export declare function buildVersionOverrideHeaders(workerName: string | undefined, versionId: string): HeadersInit | undefined;
 export declare function deploy(options: DeployOptions): Promise<void>;