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

package/dist/cli.d.ts

@@ -1 +1 @@
-export { };
+export {}

package/dist/cli.js

@@ -38,16 +38,30 @@ async function deployCommand() {
 		root: process.cwd(),
 		preview: parsed.preview,
 		env: parsed.env,
+		config: parsed.config,
 		skipBuild: parsed.skipBuild,
 		dryRun: parsed.dryRun,
+		verbose: parsed.verbose,
 		name: parsed.name,
 		prerenderAll: parsed.prerenderAll,
 		prerenderConcurrency: parsed.prerenderConcurrency,
 		warmCdnCache: parsed.warmCdnCache,
+		warmCdnTarget: parsed.warmCdnTarget,
 		warmCdnConcurrency: parsed.warmCdnConcurrency,
 		warmCdnTimeout: parsed.warmCdnTimeout,
 		warmCdnRetries: parsed.warmCdnRetries,
-		warmCdnStrict: parsed.warmCdnStrict,
+		warmCdnDiscoveryTimeout: parsed.warmCdnDiscoveryTimeout,
+		warmCdnDiscoveryRetries: parsed.warmCdnDiscoveryRetries,
+		warmCdnProbeTimeout: parsed.warmCdnProbeTimeout,
+		warmCdnProbeRetries: parsed.warmCdnProbeRetries,
+		warmCdnCertify: parsed.warmCdnCertify,
+		warmCdnReadinessTimeout: parsed.warmCdnReadinessTimeout,
+		warmCdnReadinessRetries: parsed.warmCdnReadinessRetries,
+		warmCdnReadinessProbes: parsed.warmCdnReadinessProbes,
+		warmCdnReadinessProbeDelay: parsed.warmCdnReadinessProbeDelay,
+		dangerouslyPromoteOnCdnWarmError: parsed.dangerouslyPromoteOnCdnWarmError,
+		warmCdnPromote: parsed.warmCdnPromote,
+		warmCdnPromotionDelay: parsed.warmCdnPromotionDelay,
 		warmCdnIncludeFallbacks: parsed.warmCdnIncludeFallbacks,
 		experimentalTPR: parsed.experimentalTPR,
 		tprCoverage: parsed.tprCoverage,

package/dist/deploy-config.d.ts

@@ -1,5 +1,4 @@
 import { VinextCacheConfig } from "vinext/internal/cache-adapters";
-
 //#region src/deploy-config.d.ts
 /**
  * Check whether an existing vite.config file already imports and uses the
@@ -9,7 +8,7 @@ import { VinextCacheConfig } from "vinext/internal/cache-adapters";
  * Returns true when the config both imports the package and invokes
  * `cloudflare(...)` in the plugin list.
  */
-declare function viteConfigHasCloudflarePlugin(root: string): boolean;
+export declare function viteConfigHasCloudflarePlugin(root: string): boolean;
 /**
  * Detect whether the Vite config assigns a CDN or data cache adapter — i.e. the
  * `cdn` or `data` field of the `vinext({ cache })` option is given a value.
@@ -18,14 +17,18 @@ declare function viteConfigHasCloudflarePlugin(root: string): boolean;
  * an unreadable or absent config is treated as configured so a deploy is never
  * blocked on a false negative.
  */
-declare function viteConfigHasCacheAdapter(root: string): boolean;
-type ResolvedKvDataAdapterConfig = {
+export declare function viteConfigHasCacheAdapter(root: string): boolean;
+export type ResolvedKvDataAdapterConfig = {
   binding: string;
   appPrefix?: string;
   ttlSeconds?: number;
 };
-declare function resolveKvDataAdapterConfig(cache: VinextCacheConfig | null | undefined): ResolvedKvDataAdapterConfig | null;
-declare function viteConfigHasImageAdapter(root: string): boolean;
+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
  * backend imperatively via one of the `setCacheHandler` / `setDataCacheHandler`
@@ -40,16 +43,15 @@ declare function viteConfigHasImageAdapter(root: string): boolean;
  * missing Worker entry returns false (nothing to inspect — defer to other
  * checks).
  */
-declare function workerEntryHasCacheHandler(root: string): boolean;
+export declare function workerEntryHasCacheHandler(root: string): boolean;
 /**
  * Build the error thrown when an ISR/cached app is deployed without a cache
  * adapter configured in the Vite config. Production deployments need a
  * persistent cache backend; vinext no longer scaffolds one into the Worker
  * entry, so it must be declared via `vinext({ cache })`.
  */
-declare function formatMissingCacheAdapterError(options: {
+export declare function formatMissingCacheAdapterError(options: {
   configFile?: string;
 }): string;
-declare function formatImageOptimizationHint(): string;
-//#endregion
-export { ResolvedKvDataAdapterConfig, formatImageOptimizationHint, formatMissingCacheAdapterError, resolveKvDataAdapterConfig, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler };
+export declare function formatImageOptimizationHint(): string;
+//#endregion

package/dist/deploy-config.js

@@ -1,6 +1,8 @@
 import { DEFAULT_KV_DATA_CACHE_BINDING } from "./cache/kv-data-adapter.js";
-import path from "node:path";
+import { DEFAULT_CDN_VERSION_METADATA_BINDING } from "./cache/cdn-adapter.js";
 import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { findViteConfigPath } from "vinext/internal/utils/project";
 //#region src/deploy-config.ts
 function escapeRegExp(value) {
@@ -84,9 +86,25 @@ function viteConfigHasCacheAdapter(root) {
 		return true;
 	}
 	const block = extractCacheBlock(content);
-	if (!block) return false;
+	if (!block) {
+		const assigned = /\bcache\s*:\s*([^,}\n]+)/.exec(content)?.[1].trim();
+		return Boolean(assigned && assigned !== "undefined" && assigned !== "null");
+	}
 	return cacheFieldAssigned(block, "cdn") || cacheFieldAssigned(block, "data");
 }
+function isCloudflareCdnAdapterPath(adapter) {
+	const normalized = adapter.replace(/\\/g, "/");
+	return ["cdn-adapter.runtime", "response-store-cdn.runtime"].some((runtime) => {
+		const bundledRuntime = fileURLToPath(new URL(`./cache/${runtime}.js`, import.meta.url)).replace(/\\/g, "/");
+		return normalized === `@vinext/cloudflare/cache/${runtime}` || normalized === `@vinext/cloudflare/cache/${runtime}.js` || normalized === bundledRuntime;
+	});
+}
+function resolveCdnAdapterConfig(cache) {
+	const cdn = cache?.cdn;
+	if (!cdn?.adapter || !isCloudflareCdnAdapterPath(cdn.adapter)) return null;
+	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");
@@ -166,4 +184,4 @@ function formatImageOptimizationHint() {
 	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, resolveKvDataAdapterConfig, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler };
+export { formatImageOptimizationHint, formatMissingCacheAdapterError, resolveCdnAdapterConfig, resolveKvDataAdapterConfig, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler };

package/dist/deploy-help.d.ts

@@ -1,5 +1,4 @@
 //#region src/deploy-help.d.ts
-declare function formatDeployHelp(): string;
-declare function printDeployHelp(): void;
-//#endregion
-export { formatDeployHelp, printDeployHelp };
+export declare function formatDeployHelp(): string;
+export declare function printDeployHelp(): void;
+//#endregion

package/dist/deploy-help.js

@@ -18,6 +18,9 @@ function formatDeployHelp() {
     --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
+    --no-promote             Do not promote the uploaded Worker version to 100%
+                             traffic
     --prerender-all          Pre-render discovered routes after building (future
                              releases will auto-populate the remote cache)
     --prerender-concurrency <count>
@@ -25,29 +28,63 @@ function formatDeployHelp() {
     --experimental-warm-cdn-cache
                              Upload a Worker version, warm build-discovered paths
                              through the production URL, then promote it (experimental)
+    --warm-cdn-target <origin>
+                             HTTPS origin to use for discovery, probing, and warming
+                             (overrides URLs inferred from Wrangler output)
     --warm-cdn-concurrency <count>
-                             Maximum number of CDN warmup requests in parallel
-    --warm-cdn-timeout <ms>  Per-request CDN warmup timeout (default: 5000)
-    --warm-cdn-retries <n>   Retries for transient CDN warmup failures (default: 1)
-    --warm-cdn-strict        Fail deploy when any CDN warmup request fails
+                             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;
+                             staged-version propagation default: 60)
+    --warm-cdn-discovery-timeout <ms>
+                             Total staged path-discovery deadline (default: 120000)
+    --warm-cdn-discovery-retries <n>
+                             Optional staged path-discovery retry limit
+                             (default: derived from the discovery deadline)
+    --warm-cdn-probe-timeout <ms>
+                             Abort when cacheability probing makes no progress for
+                             this duration (default: 120000)
+    --warm-cdn-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>
+                             Explicit total staged-readiness deadline (default:
+                             120000)
+    --warm-cdn-readiness-retries <n>
+                             Staged-readiness retries (default: 60)
+    --warm-cdn-readiness-probes <count>
+                             Consecutive successful staged-readiness probes
+                             required before warming (default: 6)
+    --warm-cdn-readiness-probe-delay <ms>
+                             Delay between staged-readiness probes (default: 1000)
+    --dangerously-promote-on-cdn-warm-error
+                             Promote even when ordinary staged warmup cannot be
+                             verified (never bypasses --warm-cdn-certify)
+    --warm-cdn-promotion-delay <ms>
+                             Delay before promotion after warmup (default: 15000)
     --warm-cdn-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)
+    --experimental-traffic-aware-warm-cache
+                                     Select CDN pre-warm 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 --experimental-warm-cdn-cache. It requires a custom
+  domain and a CLOUDFLARE_API_TOKEN with Zone Analytics read permission.
 
-  CDN warmup requests populate the edge cache only in the Cloudflare data centers
-  reached by the warmup run; they do not globally prefill every edge location.
+  Legacy --experimental-tpr and --tpr-* aliases remain supported.
+
+  Workers Cache automatically uses tiered caching. Warmed entries can therefore
+  be reused outside the data center reached by the warmup request after cache
+  propagation, but the deploy does not wait for every edge location to fill.
 
   Examples:
     npx @vinext/cloudflare deploy                                      Build and deploy to production
@@ -58,10 +95,16 @@ function formatDeployHelp() {
     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 --no-promote                              Upload a version without changing deployment traffic
     vinext-cloudflare deploy --experimental-warm-cdn-cache              Warm build-discovered paths during version deploy (experimental)
-    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 --experimental-warm-cdn-cache --warm-cdn-target https://example.com
+                                                                          Warm an explicit production origin
+    vinext-cloudflare deploy --experimental-traffic-aware-warm-cache
+                                                                          Enable traffic-aware warming
+    vinext-cloudflare deploy --experimental-traffic-aware-warm-cache --traffic-aware-coverage 95
+                                                                          Cover 95% of traffic
+    vinext-cloudflare deploy --experimental-traffic-aware-warm-cache --traffic-aware-limit 500
+                                                                          Cap at 500 routes
 `;
 }
 function printDeployHelp() {

package/dist/deploy.d.ts

@@ -1,31 +1,80 @@
-import { parseWranglerConfig } from "./tpr.js";
+import { CdnWarmOptions, CdnWarmRequestPlan, PrerenderWarmPlan } from "./cdn-warm.js";
+import { parseWranglerConfig } from "./wrangler-config.js";
+import { TrafficEntry } from "./tpr.js";
 import { WranglerDeploymentStatus, WranglerVersionTraffic } from "./version-deploy.js";
 import { KVBulkPair } from "./prerender-kv-populate.js";
 import { spawn } from "node:child_process";
-
+import { VinextCacheConfig } from "vinext/internal/config/prerender";
+import { ProjectInfo } from "vinext/internal/utils/project";
 //#region src/deploy.d.ts
-type DeployOptions = {
-  /** Project root directory */root: string; /** Deploy to preview environment (default: production) */
-  preview?: boolean; /** Wrangler environment name from wrangler.jsonc env.<name> */
-  env?: string; /** Custom project name for the Worker */
-  name?: string; /** Wrangler config path, relative to root unless absolute */
-  config?: string; /** Skip the build step (assume already built) */
-  skipBuild?: boolean; /** Dry run — validate setup but don't build or deploy */
-  dryRun?: boolean; /** Pre-render all discovered routes into the dist output after building */
-  prerenderAll?: boolean; /** Maximum number of routes to prerender in parallel */
-  prerenderConcurrency?: number; /** Warm Cloudflare's CDN cache by requesting build-discovered paths for the uploaded version */
-  warmCdnCache?: boolean; /** Maximum number of CDN warmup requests to issue in parallel */
-  warmCdnConcurrency?: number; /** Per-request CDN warmup timeout in milliseconds */
-  warmCdnTimeout?: number; /** Number of CDN warmup retries for transient failures */
-  warmCdnRetries?: number; /** Fail deployment if any CDN warmup request fails */
-  warmCdnStrict?: boolean; /** Include PPR fallback-shell placeholder paths during CDN warmup */
-  warmCdnIncludeFallbacks?: boolean; /** Enable experimental TPR (Traffic-aware Pre-Rendering) */
-  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) */
-  tprLimit?: number; /** TPR: analytics lookback window in hours (default: 24) */
+export declare const DEFAULT_CDN_WARM_PROMOTION_DELAY_MS = 15000;
+export type DeployOptions = {
+  /** Project root directory */
+  root: string;
+  /** Deploy to preview environment (default: production) */
+  preview?: boolean;
+  /** Wrangler environment name from wrangler.jsonc env.<name> */
+  env?: string;
+  /** Custom project name for the Worker */
+  name?: string;
+  /** Wrangler config path, relative to root unless absolute */
+  config?: string;
+  /** Skip the build step (assume already built) */
+  skipBuild?: boolean;
+  /** Dry run — validate setup but don't build or deploy */
+  dryRun?: boolean;
+  /** Print raw output from internal Wrangler commands. */
+  verbose?: boolean;
+  /** Pre-render all discovered routes into the dist output after building */
+  prerenderAll?: boolean;
+  /** Maximum number of routes to prerender in parallel */
+  prerenderConcurrency?: number;
+  /** Warm Cloudflare's CDN cache by requesting build-discovered paths for the uploaded version */
+  warmCdnCache?: boolean;
+  /** Explicit production origin to use for CDN discovery, probing, and warming */
+  warmCdnTarget?: string;
+  /** Maximum number of CDN warmup requests to issue in parallel */
+  warmCdnConcurrency?: number;
+  /** Per-request CDN warmup timeout in milliseconds */
+  warmCdnTimeout?: number;
+  /** Number of CDN warmup retries for transient failures */
+  warmCdnRetries?: number;
+  /** Maximum duration of staged Worker path discovery */
+  warmCdnDiscoveryTimeout?: number;
+  /** Number of transient staged Worker path discovery retries */
+  warmCdnDiscoveryRetries?: number;
+  /** Abort after this duration without a completed cacheability probe */
+  warmCdnProbeTimeout?: number;
+  /** Number of transient staged Worker cacheability probe retries */
+  warmCdnProbeRetries?: number;
+  /** Re-request warmed identities and require reusable CDN hits before promotion */
+  warmCdnCertify?: boolean;
+  /** Maximum duration of staged Worker readiness verification */
+  warmCdnReadinessTimeout?: number;
+  /** Number of staged Worker readiness retries */
+  warmCdnReadinessRetries?: number;
+  /** Consecutive successful probes required before warming the staged Worker */
+  warmCdnReadinessProbes?: number;
+  /** Delay between staged Worker readiness probes in milliseconds */
+  warmCdnReadinessProbeDelay?: number;
+  /** Promote even when staged CDN warmup cannot be completed */
+  dangerouslyPromoteOnCdnWarmError?: boolean;
+  /** 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;
+  /** 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 selected routes (default: 1000) */
+  tprLimit?: number;
+  /** TPR: analytics lookback window in hours (default: 24) */
   tprWindow?: number;
 };
-declare function parseDeployArgs(args: string[]): {
+export declare function parseDeployArgs(args: string[]): {
   help: boolean;
   preview: boolean;
   env: string | undefined;
@@ -33,13 +82,26 @@ declare function parseDeployArgs(args: string[]): {
   config: string | undefined;
   skipBuild: boolean;
   dryRun: boolean;
+  verbose: boolean;
   prerenderAll: boolean;
   prerenderConcurrency: number | undefined;
   warmCdnCache: boolean;
+  warmCdnTarget: string | undefined;
   warmCdnConcurrency: number | undefined;
   warmCdnTimeout: number | undefined;
   warmCdnRetries: number | undefined;
-  warmCdnStrict: boolean;
+  warmCdnDiscoveryTimeout: number | undefined;
+  warmCdnDiscoveryRetries: number | undefined;
+  warmCdnProbeTimeout: number | undefined;
+  warmCdnProbeRetries: number | undefined;
+  warmCdnCertify: boolean;
+  warmCdnReadinessTimeout: number | undefined;
+  warmCdnReadinessRetries: number | undefined;
+  warmCdnReadinessProbes: number | undefined;
+  warmCdnReadinessProbeDelay: number | undefined;
+  dangerouslyPromoteOnCdnWarmError: boolean;
+  warmCdnPromote: boolean;
+  warmCdnPromotionDelay: number | undefined;
   warmCdnIncludeFallbacks: boolean;
   experimentalTPR: boolean;
   tprCoverage: number | undefined;
@@ -58,7 +120,7 @@ declare function parseDeployArgs(args: string[]): {
  *
  * Passing `undefined` is a no-op; the callback runs with `process.env` untouched.
  */
-declare function withCloudflareEnv<T>(env: string | undefined, fn: () => Promise<T>): Promise<T>;
+export declare function withCloudflareEnv<T>(env: string | undefined, fn: () => Promise<T>): Promise<T>;
 type WranglerDeployArgs = {
   args: string[];
   env: string | undefined;
@@ -67,9 +129,9 @@ type WranglerKVBulkPutArgs = {
   args: string[];
   env: string | undefined;
 };
-declare function validateWranglerEnvName(env: string): string;
-declare function buildWranglerDeployArgs(options: Pick<DeployOptions, "preview" | "env" | "name" | "config">): WranglerDeployArgs;
-declare function buildWranglerKVBulkPutArgs(options: {
+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;
@@ -80,30 +142,48 @@ declare function buildWranglerKVBulkPutArgs(options: {
  * Invoking the JavaScript file through `process.execPath` avoids the `.cmd`
  * shim and command shell that package managers create on Windows.
  */
-declare function resolveWranglerBin(root: string, resolvePackageJson?: (root: string) => string | null): string;
-declare function buildNodeCliInvocation(scriptPath: string, args: string[], nodeExecutable?: string): {
+export declare function resolveWranglerBin(root: string, resolvePackageJson?: (root: string) => string | null): string;
+export declare function buildNodeCliInvocation(scriptPath: string, args: string[], nodeExecutable?: string): {
   file: string;
   args: string[];
 };
-declare function buildWranglerInvocation(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config">, nodeExecutable?: string): {
+export declare function buildWranglerInvocation(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config">, nodeExecutable?: string): {
   file: string;
   args: string[];
   env: string | undefined;
 };
-declare function runWranglerKVBulkPut(root: string, options: {
+export declare function runWranglerKVBulkPut(root: string, options: {
   binding: string;
   env?: string;
   pairs: KVBulkPair[];
   tempDir?: string;
 }, execute?: typeof spawn, nodeExecutable?: string): Promise<void>;
-declare function runWranglerDeploy(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config">, execute?: typeof spawn): Promise<string>;
-declare function deployWithCdnWarmup(root: string, paths: readonly string[], options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "warmCdnConcurrency" | "warmCdnTimeout" | "warmCdnRetries" | "warmCdnStrict">): Promise<string>;
-declare function resolveCdnWarmupTargetUrl(root: string, deployedUrl: string | null): string | null;
-declare function resolveCdnWarmupTargetUrl(root: string, deployedUrl: string | null, options: Pick<DeployOptions, "preview" | "env" | "config">): string | null;
-declare function getZeroPercentStagingTraffic(deployment: WranglerDeploymentStatus | null, versionId: string): WranglerVersionTraffic[] | null;
+export declare function runWranglerDeploy(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose"> & {
+  promote?: boolean;
+}, 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"> & {
+  /** 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;
+};
+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>>;
-declare function resolveWorkerNameForVersionOverride(config: ParsedWranglerConfig | null, options: Pick<DeployOptions, "preview" | "env" | "name">): string | undefined;
-declare function buildVersionOverrideHeaders(workerName: string | undefined, versionId: string): HeadersInit | undefined;
-declare function deploy(options: DeployOptions): Promise<void>;
-//#endregion
-export { DeployOptions, buildNodeCliInvocation, buildVersionOverrideHeaders, buildWranglerDeployArgs, buildWranglerInvocation, buildWranglerKVBulkPutArgs, deploy, deployWithCdnWarmup, getZeroPercentStagingTraffic, parseDeployArgs, resolveCdnWarmupTargetUrl, resolveWorkerNameForVersionOverride, resolveWranglerBin, runWranglerDeploy, runWranglerKVBulkPut, validateWranglerEnvName, withCloudflareEnv };
+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>;
+//#endregion