@vinext/cloudflare 0.2.1 → 1.0.0-beta.0

package/dist/cache/kv-data-adapter.d.ts

@@ -1,4 +1,5 @@
 //#region src/cache/kv-data-adapter.d.ts
+declare const DEFAULT_KV_DATA_CACHE_BINDING = "VINEXT_KV_CACHE";
 /** Options accepted by {@link kvDataAdapter}, forwarded to the runtime factory. */
 type KvDataAdapterOptions = {
   /** KV namespace binding name on the Worker `env`. @default "VINEXT_KV_CACHE" */binding?: string; /** Namespace prefix for cache keys (isolates multiple apps in one namespace). */
@@ -24,4 +25,4 @@ declare function kvDataAdapter(options?: KvDataAdapterOptions): {
   options: KvDataAdapterOptions | undefined;
 };
 //#endregion
-export { KvDataAdapterOptions, kvDataAdapter };
+export { DEFAULT_KV_DATA_CACHE_BINDING, KvDataAdapterOptions, kvDataAdapter };

package/dist/cache/kv-data-adapter.js

@@ -1,5 +1,6 @@
 import { fileURLToPath } from "node:url";
 //#region src/cache/kv-data-adapter.ts
+const DEFAULT_KV_DATA_CACHE_BINDING = "VINEXT_KV_CACHE";
 /**
 * Cloudflare KV data cache.
 *
@@ -21,4 +22,4 @@ function kvDataAdapter(options) {
 	};
 }
 //#endregion
-export { kvDataAdapter };
+export { DEFAULT_KV_DATA_CACHE_BINDING, kvDataAdapter };

package/dist/cdn-warm.d.ts

@@ -0,0 +1,37 @@
+import { PrerenderManifest, PrerenderedPathSelectionOptions } from "vinext/internal/server/prerender-manifest";
+
+//#region src/cdn-warm.d.ts
+type CdnWarmOptions = {
+  targetUrl: string;
+  paths: readonly string[];
+  headers?: HeadersInit;
+  concurrency?: number;
+  timeoutMs?: number;
+  retries?: number;
+  strict?: boolean;
+  fetchImpl?: typeof fetch;
+};
+declare const DEFAULT_CDN_WARM_TIMEOUT_MS = 5000;
+type PrerenderCdnWarmOptions = Omit<CdnWarmOptions, "paths"> & {
+  root: string;
+  includeFallbackShells?: boolean;
+};
+type CdnWarmResult = {
+  total: number;
+  warmed: number;
+  failed: number;
+  failures: Array<{
+    path: string;
+    error: string;
+  }>;
+};
+declare function readPrerenderWarmPaths(root: string, options?: {
+  includeFallbackShells?: boolean;
+  strict?: boolean;
+}): string[];
+declare function getWarmPathsFromPrerenderManifest(manifest: PrerenderManifest, options?: PrerenderedPathSelectionOptions): string[];
+declare function buildWarmupUrl(targetUrl: string, pathname: string): URL;
+declare function warmCdnCache(options: CdnWarmOptions): Promise<CdnWarmResult>;
+declare function warmCdnCacheFromPrerender(options: PrerenderCdnWarmOptions): Promise<CdnWarmResult>;
+//#endregion
+export { CdnWarmOptions, CdnWarmResult, DEFAULT_CDN_WARM_TIMEOUT_MS, PrerenderCdnWarmOptions, buildWarmupUrl, getWarmPathsFromPrerenderManifest, readPrerenderWarmPaths, warmCdnCache, warmCdnCacheFromPrerender };

package/dist/cdn-warm.js

@@ -0,0 +1,183 @@
+import path from "node:path";
+import fs from "node:fs";
+import { PRERENDER_PATHS_MANIFEST } from "vinext/internal/build/prerender-paths";
+import { getPrerenderedConcretePaths, readPrerenderManifest } from "vinext/internal/server/prerender-manifest";
+//#region src/cdn-warm.ts
+const DEFAULT_CDN_WARM_TIMEOUT_MS = 5e3;
+function readBuiltBuildId(root) {
+	try {
+		const buildId = fs.readFileSync(path.join(root, "dist", "server", "BUILD_ID"), "utf-8").trim();
+		return buildId.length > 0 ? buildId : null;
+	} catch (error) {
+		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+function readPrerenderPathManifest(manifestPath) {
+	if (!fs.existsSync(manifestPath)) return null;
+	try {
+		const parsed = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+		if (!parsed || typeof parsed !== "object") return null;
+		const manifest = parsed;
+		if (!Array.isArray(manifest.paths)) return null;
+		return manifest;
+	} catch (error) {
+		console.warn(`[vinext] Failed to read prerender path manifest at ${manifestPath}:`, error);
+		return null;
+	}
+}
+function readPrerenderPathWarmPaths(root, options) {
+	const manifest = readPrerenderPathManifest(path.join(root, "dist", "server", PRERENDER_PATHS_MANIFEST));
+	if (!manifest) return null;
+	const builtBuildId = readBuiltBuildId(root);
+	if (!manifest.buildId || !builtBuildId || manifest.buildId !== builtBuildId) {
+		const message = "[vinext] CDN warmup skipped: prerender path manifest buildId does not match dist/server/BUILD_ID.";
+		if (options?.strict) throw new Error(message);
+		console.warn(message);
+		return [];
+	}
+	return manifest.paths.filter((pathname) => pathname.startsWith("/"));
+}
+function readPrerenderWarmPaths(root, options) {
+	const shouldPreferPrerenderManifest = options?.includeFallbackShells === true;
+	if (!shouldPreferPrerenderManifest) {
+		const pathManifestPaths = readPrerenderPathWarmPaths(root, options);
+		if (pathManifestPaths !== null) return pathManifestPaths;
+	}
+	const manifest = readPrerenderManifest(path.join(root, "dist", "server", "vinext-prerender.json"));
+	if (!manifest) {
+		if (shouldPreferPrerenderManifest) {
+			const pathManifestPaths = readPrerenderPathWarmPaths(root, options);
+			if (pathManifestPaths !== null) {
+				console.warn("[vinext] CDN warmup fallback shells requested, but prerender manifest not found; warming build-discovered paths only.");
+				return pathManifestPaths;
+			}
+		}
+		const message = "[vinext] CDN warmup skipped: prerender manifest not found.";
+		if (options?.strict) throw new Error(message);
+		return [];
+	}
+	const builtBuildId = readBuiltBuildId(root);
+	if (!manifest.buildId || !builtBuildId || manifest.buildId !== builtBuildId) {
+		const message = "[vinext] CDN warmup skipped: prerender manifest buildId does not match dist/server/BUILD_ID.";
+		if (options?.strict) throw new Error(message);
+		console.warn(message);
+		return [];
+	}
+	return getPrerenderedConcretePaths(manifest, options);
+}
+function getWarmPathsFromPrerenderManifest(manifest, options) {
+	return getPrerenderedConcretePaths(manifest, options);
+}
+function normalizeWarmPath(pathname) {
+	return pathname.startsWith("/") ? pathname : `/${pathname}`;
+}
+function buildWarmupUrl(targetUrl, pathname) {
+	return new URL(normalizeWarmPath(pathname), targetUrl.endsWith("/") ? targetUrl : `${targetUrl}/`);
+}
+function isRetryableStatus(status) {
+	return status === 408 || status === 429 || status >= 500;
+}
+async function fetchWithTimeout(fetchImpl, url, timeoutMs, headers) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	const requestHeaders = new Headers(headers);
+	requestHeaders.set("User-Agent", "vinext-cloudflare-cdn-warm");
+	try {
+		return await fetchImpl(url, {
+			method: "GET",
+			redirect: "follow",
+			headers: requestHeaders,
+			signal: controller.signal
+		});
+	} finally {
+		clearTimeout(timer);
+	}
+}
+async function warmOnePath(pathname, options) {
+	const url = buildWarmupUrl(options.targetUrl, pathname);
+	let lastError = "unknown error";
+	for (let attempt = 0; attempt <= options.retries; attempt++) try {
+		const response = await fetchWithTimeout(options.fetchImpl, url, options.timeoutMs, options.headers);
+		await response.arrayBuffer();
+		if (response.status < 400) return {
+			path: pathname,
+			ok: true
+		};
+		lastError = `HTTP ${response.status}`;
+		if (!isRetryableStatus(response.status)) break;
+	} catch (error) {
+		if (error instanceof DOMException && error.name === "AbortError") lastError = `timed out after ${options.timeoutMs}ms`;
+		else lastError = error instanceof Error ? error.message : String(error);
+	}
+	return {
+		path: pathname,
+		ok: false,
+		error: lastError
+	};
+}
+async function runWithConcurrency(items, concurrency, fn) {
+	const results = Array.from({ length: items.length });
+	let nextIndex = 0;
+	async function worker() {
+		while (nextIndex < items.length) {
+			const index = nextIndex++;
+			results[index] = await fn(items[index]);
+		}
+	}
+	if (items.length === 0) return results;
+	const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => worker());
+	await Promise.all(workers);
+	return results;
+}
+async function warmCdnCache(options) {
+	const paths = options.paths;
+	const concurrency = Math.max(1, options.concurrency ?? 10);
+	const timeoutMs = Math.max(1, options.timeoutMs ?? 5e3);
+	const retries = Math.max(0, options.retries ?? 1);
+	const fetchImpl = options.fetchImpl ?? fetch;
+	if (paths.length === 0) return {
+		total: 0,
+		warmed: 0,
+		failed: 0,
+		failures: []
+	};
+	console.log(`\n  Warming CDN cache for ${paths.length} build-discovered path(s)...`);
+	const results = await runWithConcurrency(paths, concurrency, (pathname) => warmOnePath(pathname, {
+		targetUrl: options.targetUrl,
+		timeoutMs,
+		retries,
+		fetchImpl,
+		headers: options.headers
+	}));
+	const failures = results.filter((result) => !result.ok).map(({ path, error }) => ({
+		path,
+		error
+	}));
+	const warmed = results.length - failures.length;
+	console.log(`  CDN warmup: ${warmed}/${paths.length} path(s) warmed.`);
+	if (failures.length > 0) {
+		for (const failure of failures.slice(0, 5)) console.warn(`  CDN warmup failed for ${failure.path}: ${failure.error}`);
+		if (failures.length > 5) console.warn(`  CDN warmup: ${failures.length - 5} additional failure(s) omitted.`);
+	}
+	const result = {
+		total: paths.length,
+		warmed,
+		failed: failures.length,
+		failures
+	};
+	if (options.strict && failures.length > 0) throw new Error(`CDN warmup failed for ${failures.length}/${paths.length} path(s). First failure: ${failures[0].path}: ${failures[0].error}`);
+	return result;
+}
+async function warmCdnCacheFromPrerender(options) {
+	const paths = readPrerenderWarmPaths(options.root, {
+		includeFallbackShells: options.includeFallbackShells,
+		strict: options.strict
+	});
+	return warmCdnCache({
+		...options,
+		paths
+	});
+}
+//#endregion
+export { DEFAULT_CDN_WARM_TIMEOUT_MS, buildWarmupUrl, getWarmPathsFromPrerenderManifest, readPrerenderWarmPaths, warmCdnCache, warmCdnCacheFromPrerender };

package/dist/cli.js

@@ -43,6 +43,12 @@ async function deployCommand() {
 		name: parsed.name,
 		prerenderAll: parsed.prerenderAll,
 		prerenderConcurrency: parsed.prerenderConcurrency,
+		warmCdnCache: parsed.warmCdnCache,
+		warmCdnConcurrency: parsed.warmCdnConcurrency,
+		warmCdnTimeout: parsed.warmCdnTimeout,
+		warmCdnRetries: parsed.warmCdnRetries,
+		warmCdnStrict: parsed.warmCdnStrict,
+		warmCdnIncludeFallbacks: parsed.warmCdnIncludeFallbacks,
 		experimentalTPR: parsed.experimentalTPR,
 		tprCoverage: parsed.tprCoverage,
 		tprLimit: parsed.tprLimit,
@@ -60,7 +66,7 @@ if (command === "--help" || command === "-h" || !command) {
 switch (command) {
 	case "deploy":
 		deployCommand().catch((error) => {
-			console.error(error);
+			console.error(error instanceof Error ? error.message : String(error));
 			process.exit(1);
 		});
 		break;

package/dist/deploy-config.d.ts

@@ -1,3 +1,5 @@
+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
@@ -17,6 +19,12 @@ declare function viteConfigHasCloudflarePlugin(root: string): boolean;
  * blocked on a false negative.
  */
 declare function viteConfigHasCacheAdapter(root: string): boolean;
+type ResolvedKvDataAdapterConfig = {
+  binding: string;
+  appPrefix?: string;
+  ttlSeconds?: number;
+};
+declare function resolveKvDataAdapterConfig(cache: VinextCacheConfig | null | undefined): ResolvedKvDataAdapterConfig | null;
 declare function viteConfigHasImageAdapter(root: string): boolean;
 /**
  * Detect whether an existing user-authored Worker entry wires up a cache
@@ -44,4 +52,4 @@ declare function formatMissingCacheAdapterError(options: {
 }): string;
 declare function formatImageOptimizationHint(): string;
 //#endregion
-export { formatImageOptimizationHint, formatMissingCacheAdapterError, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler };
+export { ResolvedKvDataAdapterConfig, formatImageOptimizationHint, formatMissingCacheAdapterError, resolveKvDataAdapterConfig, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler };

package/dist/deploy-config.js

@@ -1,5 +1,6 @@
-import fs from "node:fs";
+import { DEFAULT_KV_DATA_CACHE_BINDING } from "./cache/kv-data-adapter.js";
 import path from "node:path";
+import fs from "node:fs";
 import { findViteConfigPath } from "vinext/internal/utils/project";
 //#region src/deploy-config.ts
 function escapeRegExp(value) {
@@ -86,6 +87,24 @@ function viteConfigHasCacheAdapter(root) {
 	if (!block) return false;
 	return cacheFieldAssigned(block, "cdn") || cacheFieldAssigned(block, "data");
 }
+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;
@@ -147,4 +166,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, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler };
+export { formatImageOptimizationHint, formatMissingCacheAdapterError, resolveKvDataAdapterConfig, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler };

package/dist/deploy-help.js

@@ -15,12 +15,23 @@ function formatDeployHelp() {
     --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)
+    --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
     --prerender-all          Pre-render discovered routes after building (future
                              releases will auto-populate the remote cache)
     --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-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
+    --warm-cdn-include-fallbacks
+                             Also warm PPR fallback-shell placeholder paths
     -h, --help               Show this help
 
   Experimental:
@@ -35,14 +46,19 @@ function formatDeployHelp() {
   a custom domain (zone analytics are unavailable on *.workers.dev) and the
   CLOUDFLARE_API_TOKEN environment variable 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.
+
   Examples:
     npx @vinext/cloudflare deploy                                      Build and deploy to production
     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 --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-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

package/dist/deploy.d.ts

@@ -1,15 +1,25 @@
-import { execFileSync } from "node:child_process";
+import { parseWranglerConfig } from "./tpr.js";
+import { WranglerDeploymentStatus, WranglerVersionTraffic } from "./version-deploy.js";
+import { KVBulkPair } from "./prerender-kv-populate.js";
+import { spawn } from "node:child_process";
 
 //#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; /** Skip the build step (assume already built) */
+  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; /** Enable experimental TPR (Traffic-aware Pre-Rendering) */
+  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) */
@@ -20,10 +30,17 @@ declare function parseDeployArgs(args: string[]): {
   preview: boolean;
   env: string | undefined;
   name: string | undefined;
+  config: string | undefined;
   skipBuild: boolean;
   dryRun: boolean;
   prerenderAll: boolean;
   prerenderConcurrency: number | undefined;
+  warmCdnCache: boolean;
+  warmCdnConcurrency: number | undefined;
+  warmCdnTimeout: number | undefined;
+  warmCdnRetries: number | undefined;
+  warmCdnStrict: boolean;
+  warmCdnIncludeFallbacks: boolean;
   experimentalTPR: boolean;
   tprCoverage: number | undefined;
   tprLimit: number | undefined;
@@ -46,8 +63,17 @@ type WranglerDeployArgs = {
   args: string[];
   env: string | undefined;
 };
+type WranglerKVBulkPutArgs = {
+  args: string[];
+  env: string | undefined;
+};
 declare function validateWranglerEnvName(env: string): string;
-declare function buildWranglerDeployArgs(options: Pick<DeployOptions, "preview" | "env">): WranglerDeployArgs;
+declare function buildWranglerDeployArgs(options: Pick<DeployOptions, "preview" | "env" | "name" | "config">): WranglerDeployArgs;
+declare function buildWranglerKVBulkPutArgs(options: {
+  binding: string;
+  env?: string;
+  filePath: string;
+}): WranglerKVBulkPutArgs;
 /**
  * Resolve Wrangler's JavaScript CLI entrypoint in node_modules.
  *
@@ -59,12 +85,25 @@ declare function buildNodeCliInvocation(scriptPath: string, args: string[], node
   file: string;
   args: string[];
 };
-declare function buildWranglerInvocation(root: string, options: Pick<DeployOptions, "preview" | "env">, nodeExecutable?: string): {
+declare function buildWranglerInvocation(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config">, nodeExecutable?: string): {
   file: string;
   args: string[];
   env: string | undefined;
 };
-declare function runWranglerDeploy(root: string, options: Pick<DeployOptions, "preview" | "env">, execute?: typeof execFileSync): string;
+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;
+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, buildWranglerDeployArgs, buildWranglerInvocation, deploy, parseDeployArgs, resolveWranglerBin, runWranglerDeploy, validateWranglerEnvName, withCloudflareEnv };
+export { DeployOptions, buildNodeCliInvocation, buildVersionOverrideHeaders, buildWranglerDeployArgs, buildWranglerInvocation, buildWranglerKVBulkPutArgs, deploy, deployWithCdnWarmup, getZeroPercentStagingTraffic, parseDeployArgs, resolveCdnWarmupTargetUrl, resolveWorkerNameForVersionOverride, resolveWranglerBin, runWranglerDeploy, runWranglerKVBulkPut, validateWranglerEnvName, withCloudflareEnv };