@vinext/cloudflare 1.0.0-beta.8 → 1.0.0

package/dist/deploy.js

@@ -1,27 +1,29 @@
 import { writeCacheabilityManifestArtifact } from "./cacheability-artifact.js";
 import { DEFAULT_CACHEABILITY_PROBE_RETRY_DELAY_MS, probeStagedWorkerCacheability, readPrerenderSecret } from "./cacheability-probe.js";
 import { CdnOperationProgress, createCdnWarmTargets, createPrerenderWarmPlan, waitForCdnWarmTargetReadiness, warmCdnCache } from "./cdn-warm.js";
-import { parseWranglerConfig, runTPR } from "./tpr.js";
+import { parseWranglerConfig } from "./wrangler-config.js";
+import { resolveTPRRoutes, selectRoutes } from "./tpr.js";
 import { VINEXT_EXPECTED_WORKER_VERSION_HEADER } from "./version-headers.js";
-import { formatImageOptimizationHint, formatMissingCacheAdapterError, resolveCdnAdapterConfig, resolveKvDataAdapterConfig, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler } from "./deploy-config.js";
+import { formatImageOptimizationHint, formatMissingCacheAdapterError, resolveCdnAdapterConfig, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, viteConfigHasImageAdapter, workerEntryHasCacheHandler } from "./deploy-config.js";
 import { assertCdnVersionMetadataConfig } from "./wrangler-version-metadata.js";
 import { parseWorkerDeploymentUrl } from "./worker-deployment-url.js";
-import { runWranglerDeploymentStatus, runWranglerTriggersDeploy, runWranglerVersionDeploy, runWranglerVersionUpload } from "./version-deploy.js";
-import { buildPrerenderKVPairs } from "./prerender-kv-populate.js";
+import { readBuildOutputWorkerName, runCfDeploymentStatus, runCfTriggersDeploy, runCfVersionDeploy, runCfVersionUpload, runWranglerDeploymentStatus, runWranglerTriggersDeploy, runWranglerVersionDeploy, runWranglerVersionUpload } from "./version-deploy.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
 import { cacheabilityRoutePathname } from "vinext/internal/server/cacheability-manifest";
 import { setTimeout } from "node:timers/promises";
 import { DEFAULT_REMOTE_PATH_DISCOVERY_PHASE_TIMEOUT_MS, DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS, discoverPrerenderPathManifest, emitPrerenderPathManifest } from "vinext/internal/build/prerender-paths";
-import os from "node:os";
+import { normalizePathTrailingSlash } from "vinext/shims/url-utils";
 import { spawn } from "node:child_process";
 import { parseArgs } from "node:util";
 import { pathToFileURL } from "node:url";
+import { VINEXT_BUILD_LIFECYCLE_CONFIG } from "vinext/internal/build/lifecycle";
 import { runPrerender } from "vinext/internal/build/run-prerender";
+import { printBuildReport } from "vinext/internal/build/report";
 import { loadDotenv } from "vinext/internal/config/dotenv";
 import { findVinextNextConfigInPlugins, loadNextConfig, resolveNextConfig, resolveNextConfigInput } from "vinext/internal/config/next-config";
-import { findVinextCacheConfigInPlugins, findVinextPrerenderConfigInPlugins, findVinextRouteRootConfigInPlugins, formatVinextPrerenderLabel, hasBuildIdentityResponseHeader, hasUncachedRequestRouting, hasVerbatimResponseVary, isConfiguredCdnResponsePolicyHeader, requiresRouteCacheabilityProbeManifest, resolveVinextPrerenderDecision, supportsCanonicalRscWarmup, usesVinextCacheWarmupStatus } from "vinext/internal/config/prerender";
+import { cacheWarmupStatusSource, finalizeCacheAdapterPrerenderOutput, findVinextCacheConfigInPlugins, findVinextPrerenderConfigInPlugins, findVinextRouteRootConfigInPlugins, formatVinextPrerenderLabel, hasBuildIdentityResponseHeader, hasCacheAdapterPrerenderOutput, hasUncachedRequestRouting, hasVerbatimResponseVary, isConfiguredCdnResponsePolicyHeader, requiresRouteCacheabilityProbeManifest, resolveVinextPrerenderDecision, supportsCanonicalRscWarmup } from "vinext/internal/config/prerender";
 import { detectProject, findInNodeModules, formatMissingCloudflarePluginError, getMissingDeps } from "vinext/internal/utils/project";
 import { PHASE_PRODUCTION_BUILD } from "vinext/shims/constants";
 //#region src/deploy.ts
@@ -35,6 +37,17 @@ import { PHASE_PRODUCTION_BUILD } from "vinext/shims/constants";
 *   3. Deploys to Cloudflare Workers via Wrangler
 */
 const DEFAULT_CDN_WARM_PROMOTION_DELAY_MS = 15e3;
+/** The typed cf Vite plugin emits Worker and asset bundles into Build Output. */
+function resolvePrerenderOutputDirs(root, deploymentTool, configured) {
+	if (deploymentTool !== "cf") return configured;
+	const workerDir = path.join(root, ".cloudflare", "output", "v0", "workers", "default");
+	if (!fs.existsSync(path.join(workerDir, "worker.config.json"))) return configured;
+	return {
+		...configured,
+		rscOutDir: path.join(workerDir, "bundle"),
+		clientOutDir: path.join(workerDir, "assets")
+	};
+}
 function parsePositiveIntegerArg(raw, flag) {
 	if (raw === "") throw new Error(`${flag} requires a value, but none was provided.`);
 	const parsed = Number(raw);
@@ -54,7 +67,7 @@ function validateTimerDelay(value, flag, raw = String(value)) {
 	return value;
 }
 function validatePromotionDelay(value, raw = String(value)) {
-	return validateTimerDelay(value, "--warm-cdn-promotion-delay", raw);
+	return validateTimerDelay(value, "--warm-cache-promotion-delay", raw);
 }
 function validateCdnWarmTarget(raw) {
 	const value = raw.trim();
@@ -62,15 +75,16 @@ function validateCdnWarmTarget(raw) {
 	try {
 		url = new URL(value);
 	} catch {
-		throw new Error(`--warm-cdn-target expects an HTTPS origin, but got "${raw}".`);
+		throw new Error(`--warm-cache-target expects an HTTPS origin, but got "${raw}".`);
 	}
-	if (url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.port !== "" || url.pathname !== "/" || url.search !== "" || url.hash !== "") throw new Error(`--warm-cdn-target expects an HTTPS origin without a path, query, credentials, or port, but got "${raw}".`);
+	if (url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.port !== "" || url.pathname !== "/" || url.search !== "" || url.hash !== "") throw new Error(`--warm-cache-target expects an HTTPS origin without a path, query, credentials, or port, but got "${raw}".`);
 	return url.origin;
 }
 function formatUnknownError(error) {
 	if (error instanceof Error && error.message) return error.message;
 	return String(error);
 }
+var StagedWarmupError = class extends Error {};
 /** Deploy command flag definitions for util.parseArgs. */
 const deployArgOptions = {
 	help: {
@@ -102,6 +116,54 @@ const deployArgOptions = {
 		default: false
 	},
 	"prerender-concurrency": { type: "string" },
+	"warm-cache": {
+		type: "boolean",
+		default: false
+	},
+	"warm-cache-target": { type: "string" },
+	"warm-cache-concurrency": { type: "string" },
+	"warm-cache-timeout": { type: "string" },
+	"warm-cache-retries": { type: "string" },
+	"warm-cache-discovery-timeout": { type: "string" },
+	"warm-cache-discovery-retries": { type: "string" },
+	"warm-cache-probe-timeout": { type: "string" },
+	"warm-cache-probe-retries": { type: "string" },
+	"warm-cache-certify": {
+		type: "boolean",
+		default: false
+	},
+	"warm-cache-readiness-timeout": { type: "string" },
+	"warm-cache-readiness-retries": { type: "string" },
+	"warm-cache-readiness-probes": { type: "string" },
+	"warm-cache-readiness-probe-delay": { type: "string" },
+	"dangerously-promote-on-warm-cache-error": {
+		type: "boolean",
+		default: false
+	},
+	"no-promote": {
+		type: "boolean",
+		default: false
+	},
+	"warm-cache-no-promote": {
+		type: "boolean",
+		default: false
+	},
+	"warm-cache-promotion-delay": { type: "string" },
+	"warm-cache-include-fallbacks": {
+		type: "boolean",
+		default: false
+	},
+	"traffic-aware-warm-cache": {
+		type: "boolean",
+		default: false
+	},
+	"traffic-aware-coverage": { type: "string" },
+	"traffic-aware-limit": { type: "string" },
+	"traffic-aware-window": { type: "string" },
+	"dangerously-promote-on-cdn-warm-error": {
+		type: "boolean",
+		default: false
+	},
 	"experimental-warm-cdn-cache": {
 		type: "boolean",
 		default: false
@@ -122,10 +184,6 @@ const deployArgOptions = {
 	"warm-cdn-readiness-retries": { type: "string" },
 	"warm-cdn-readiness-probes": { type: "string" },
 	"warm-cdn-readiness-probe-delay": { type: "string" },
-	"dangerously-promote-on-cdn-warm-error": {
-		type: "boolean",
-		default: false
-	},
 	"warm-cdn-no-promote": {
 		type: "boolean",
 		default: false
@@ -135,6 +193,10 @@ const deployArgOptions = {
 		type: "boolean",
 		default: false
 	},
+	"experimental-traffic-aware-warm-cache": {
+		type: "boolean",
+		default: false
+	},
 	"experimental-tpr": {
 		type: "boolean",
 		default: false
@@ -149,8 +211,29 @@ function parseDeployArgs(args) {
 		options: deployArgOptions,
 		strict: true
 	});
-	if (values["warm-cdn-certify"] && !values["experimental-warm-cdn-cache"]) throw new Error("--warm-cdn-certify requires --experimental-warm-cdn-cache.");
-	if (values["warm-cdn-target"] && !values["experimental-warm-cdn-cache"]) throw new Error("--warm-cdn-target requires --experimental-warm-cdn-cache.");
+	values["dangerously-promote-on-warm-cache-error"] ||= values["dangerously-promote-on-cdn-warm-error"];
+	values["warm-cache"] ||= values["experimental-warm-cdn-cache"];
+	values["warm-cache-target"] ??= values["warm-cdn-target"];
+	values["warm-cache-concurrency"] ??= values["warm-cdn-concurrency"];
+	values["warm-cache-timeout"] ??= values["warm-cdn-timeout"];
+	values["warm-cache-retries"] ??= values["warm-cdn-retries"];
+	values["warm-cache-discovery-timeout"] ??= values["warm-cdn-discovery-timeout"];
+	values["warm-cache-discovery-retries"] ??= values["warm-cdn-discovery-retries"];
+	values["warm-cache-probe-timeout"] ??= values["warm-cdn-probe-timeout"];
+	values["warm-cache-probe-retries"] ??= values["warm-cdn-probe-retries"];
+	values["warm-cache-certify"] ||= values["warm-cdn-certify"];
+	values["warm-cache-readiness-timeout"] ??= values["warm-cdn-readiness-timeout"];
+	values["warm-cache-readiness-retries"] ??= values["warm-cdn-readiness-retries"];
+	values["warm-cache-readiness-probes"] ??= values["warm-cdn-readiness-probes"];
+	values["warm-cache-readiness-probe-delay"] ??= values["warm-cdn-readiness-probe-delay"];
+	values["warm-cache-no-promote"] ||= values["warm-cdn-no-promote"];
+	values["warm-cache-promotion-delay"] ??= values["warm-cdn-promotion-delay"];
+	values["warm-cache-include-fallbacks"] ||= values["warm-cdn-include-fallbacks"];
+	values["traffic-aware-warm-cache"] ||= values["experimental-traffic-aware-warm-cache"];
+	const trafficAwareWarmCache = values["traffic-aware-warm-cache"] || values["experimental-tpr"];
+	const warming = values["warm-cache"] || trafficAwareWarmCache;
+	if (values["warm-cache-certify"] && !warming) throw new Error("--warm-cache-certify requires --warm-cache or --traffic-aware-warm-cache.");
+	if (values["warm-cache-target"] && !warming) throw new Error("--warm-cache-target requires --warm-cache or --traffic-aware-warm-cache.");
 	function parseIntArg(name, raw) {
 		if (!raw) return void 0;
 		const n = parseInt(raw, 10);
@@ -171,28 +254,28 @@ function parseDeployArgs(args) {
 		verbose: values.verbose,
 		prerenderAll: values["prerender-all"],
 		prerenderConcurrency: values["prerender-concurrency"] === void 0 ? void 0 : parsePositiveIntegerArg(values["prerender-concurrency"], "--prerender-concurrency"),
-		warmCdnCache: values["experimental-warm-cdn-cache"],
-		warmCdnTarget: values["warm-cdn-target"] === void 0 ? void 0 : validateCdnWarmTarget(values["warm-cdn-target"]),
-		warmCdnConcurrency: values["warm-cdn-concurrency"] === void 0 ? void 0 : parsePositiveIntegerArg(values["warm-cdn-concurrency"], "--warm-cdn-concurrency"),
-		warmCdnTimeout: values["warm-cdn-timeout"] === void 0 ? void 0 : parsePositiveIntegerArg(values["warm-cdn-timeout"], "--warm-cdn-timeout"),
-		warmCdnRetries: values["warm-cdn-retries"] === void 0 ? void 0 : parseNonNegativeIntegerArg(values["warm-cdn-retries"], "--warm-cdn-retries"),
-		warmCdnDiscoveryTimeout: values["warm-cdn-discovery-timeout"] === void 0 ? void 0 : parsePositiveIntegerArg(values["warm-cdn-discovery-timeout"], "--warm-cdn-discovery-timeout"),
-		warmCdnDiscoveryRetries: values["warm-cdn-discovery-retries"] === void 0 ? void 0 : parseNonNegativeIntegerArg(values["warm-cdn-discovery-retries"], "--warm-cdn-discovery-retries"),
-		warmCdnProbeTimeout: values["warm-cdn-probe-timeout"] === void 0 ? void 0 : parsePositiveIntegerArg(values["warm-cdn-probe-timeout"], "--warm-cdn-probe-timeout"),
-		warmCdnProbeRetries: values["warm-cdn-probe-retries"] === void 0 ? void 0 : parseNonNegativeIntegerArg(values["warm-cdn-probe-retries"], "--warm-cdn-probe-retries"),
-		warmCdnCertify: values["warm-cdn-certify"],
-		warmCdnReadinessTimeout: values["warm-cdn-readiness-timeout"] === void 0 ? void 0 : parsePositiveIntegerArg(values["warm-cdn-readiness-timeout"], "--warm-cdn-readiness-timeout"),
-		warmCdnReadinessRetries: values["warm-cdn-readiness-retries"] === void 0 ? void 0 : parseNonNegativeIntegerArg(values["warm-cdn-readiness-retries"], "--warm-cdn-readiness-retries"),
-		warmCdnReadinessProbes: values["warm-cdn-readiness-probes"] === void 0 ? void 0 : parsePositiveIntegerArg(values["warm-cdn-readiness-probes"], "--warm-cdn-readiness-probes"),
-		warmCdnReadinessProbeDelay: values["warm-cdn-readiness-probe-delay"] === void 0 ? void 0 : validateTimerDelay(parseNonNegativeIntegerArg(values["warm-cdn-readiness-probe-delay"], "--warm-cdn-readiness-probe-delay"), "--warm-cdn-readiness-probe-delay", values["warm-cdn-readiness-probe-delay"]),
-		dangerouslyPromoteOnCdnWarmError: values["dangerously-promote-on-cdn-warm-error"],
-		warmCdnPromote: !values["warm-cdn-no-promote"],
-		warmCdnPromotionDelay: values["warm-cdn-promotion-delay"] === void 0 ? void 0 : validatePromotionDelay(parseNonNegativeIntegerArg(values["warm-cdn-promotion-delay"], "--warm-cdn-promotion-delay"), values["warm-cdn-promotion-delay"]),
-		warmCdnIncludeFallbacks: values["warm-cdn-include-fallbacks"],
-		experimentalTPR: values["experimental-tpr"],
-		tprCoverage: parseIntArg("tpr-coverage", values["tpr-coverage"]),
-		tprLimit: parseIntArg("tpr-limit", values["tpr-limit"]),
-		tprWindow: parseIntArg("tpr-window", values["tpr-window"])
+		warmCdnCache: values["warm-cache"],
+		warmCdnTarget: values["warm-cache-target"] === void 0 ? void 0 : validateCdnWarmTarget(values["warm-cache-target"]),
+		warmCdnConcurrency: values["warm-cache-concurrency"] === void 0 ? void 0 : parsePositiveIntegerArg(values["warm-cache-concurrency"], "--warm-cache-concurrency"),
+		warmCdnTimeout: values["warm-cache-timeout"] === void 0 ? void 0 : parsePositiveIntegerArg(values["warm-cache-timeout"], "--warm-cache-timeout"),
+		warmCdnRetries: values["warm-cache-retries"] === void 0 ? void 0 : parseNonNegativeIntegerArg(values["warm-cache-retries"], "--warm-cache-retries"),
+		warmCdnDiscoveryTimeout: values["warm-cache-discovery-timeout"] === void 0 ? void 0 : parsePositiveIntegerArg(values["warm-cache-discovery-timeout"], "--warm-cache-discovery-timeout"),
+		warmCdnDiscoveryRetries: values["warm-cache-discovery-retries"] === void 0 ? void 0 : parseNonNegativeIntegerArg(values["warm-cache-discovery-retries"], "--warm-cache-discovery-retries"),
+		warmCdnProbeTimeout: values["warm-cache-probe-timeout"] === void 0 ? void 0 : parsePositiveIntegerArg(values["warm-cache-probe-timeout"], "--warm-cache-probe-timeout"),
+		warmCdnProbeRetries: values["warm-cache-probe-retries"] === void 0 ? void 0 : parseNonNegativeIntegerArg(values["warm-cache-probe-retries"], "--warm-cache-probe-retries"),
+		warmCdnCertify: values["warm-cache-certify"],
+		warmCdnReadinessTimeout: values["warm-cache-readiness-timeout"] === void 0 ? void 0 : parsePositiveIntegerArg(values["warm-cache-readiness-timeout"], "--warm-cache-readiness-timeout"),
+		warmCdnReadinessRetries: values["warm-cache-readiness-retries"] === void 0 ? void 0 : parseNonNegativeIntegerArg(values["warm-cache-readiness-retries"], "--warm-cache-readiness-retries"),
+		warmCdnReadinessProbes: values["warm-cache-readiness-probes"] === void 0 ? void 0 : parsePositiveIntegerArg(values["warm-cache-readiness-probes"], "--warm-cache-readiness-probes"),
+		warmCdnReadinessProbeDelay: values["warm-cache-readiness-probe-delay"] === void 0 ? void 0 : validateTimerDelay(parseNonNegativeIntegerArg(values["warm-cache-readiness-probe-delay"], "--warm-cache-readiness-probe-delay"), "--warm-cache-readiness-probe-delay", values["warm-cache-readiness-probe-delay"]),
+		dangerouslyPromoteOnCdnWarmError: values["dangerously-promote-on-warm-cache-error"],
+		warmCdnPromote: !values["no-promote"] && !values["warm-cache-no-promote"],
+		warmCdnPromotionDelay: values["warm-cache-promotion-delay"] === void 0 ? void 0 : validatePromotionDelay(parseNonNegativeIntegerArg(values["warm-cache-promotion-delay"], "--warm-cache-promotion-delay"), values["warm-cache-promotion-delay"]),
+		warmCdnIncludeFallbacks: values["warm-cache-include-fallbacks"],
+		experimentalTPR: trafficAwareWarmCache,
+		tprCoverage: parseIntArg("traffic-aware-coverage", values["traffic-aware-coverage"] ?? values["tpr-coverage"]),
+		tprLimit: parseIntArg("traffic-aware-limit", values["traffic-aware-limit"] ?? values["tpr-limit"]),
+		tprWindow: parseIntArg("traffic-aware-window", values["traffic-aware-window"] ?? values["tpr-window"])
 	};
 }
 /**
@@ -242,10 +325,13 @@ async function loadProjectWranglerApi(root) {
 		pathToFileURL(wranglerPath).href
 );
 }
-async function loadDeployViteConfigMetadata(root) {
+function resolveViteBuildMode(deploymentTool, env) {
+	return deploymentTool === "cf" ? env ?? "production" : "production";
+}
+async function loadDeployViteConfigMetadata(root, mode) {
 	const plugins = (await (await loadProjectViteApi(root)).loadConfigFromFile({
 		command: "build",
-		mode: "production"
+		mode
 	}, void 0, root))?.config.plugins;
 	return {
 		cacheConfig: await findVinextCacheConfigInPlugins(plugins),
@@ -254,32 +340,22 @@ async function loadDeployViteConfigMetadata(root) {
 		routeRootConfig: await findVinextRouteRootConfigInPlugins(plugins)
 	};
 }
-async function runBuild(info, env) {
+async function runBuild(info, env, mode) {
 	console.log("\n  Building for Cloudflare Workers...\n");
 	const { createBuilder } = await loadProjectViteApi(info.root);
+	let completed = false;
 	await withCloudflareEnv(env, async () => {
-		await (await createBuilder({ root: info.root })).buildApp();
-	});
-}
-async function populateKVCacheFromPrerenderedArtifacts(root, wranglerEnv, cacheConfig) {
-	const kvConfig = resolveKvDataAdapterConfig(cacheConfig);
-	if (!kvConfig) return;
-	const { routeCount, pairs } = buildPrerenderKVPairs(path.join(root, "dist", "server"), {
-		appPrefix: kvConfig.appPrefix,
-		ttlSeconds: kvConfig.ttlSeconds
-	});
-	if (pairs.length === 0) {
-		console.log("  KV cache: Skipping prerender upload (no App Router prerendered cache entries found).");
-		return;
-	}
-	await runWranglerKVBulkPut(root, {
-		binding: kvConfig.binding,
-		env: wranglerEnv,
-		pairs
+		const invocation = { onComplete() {
+			completed = true;
+		} };
+		await (await createBuilder({
+			root: info.root,
+			mode,
+			[VINEXT_BUILD_LIFECYCLE_CONFIG]: invocation
+		})).buildApp();
 	});
-	console.log(`  KV cache: Uploaded ${pairs.length} entr${pairs.length === 1 ? "y" : "ies"} for ${routeCount} prerendered route${routeCount === 1 ? "" : "s"}.`);
+	if (!completed) throw new Error("[vinext] The Cloudflare build lifecycle did not complete.");
 }
-const KV_BULK_PUT_CHUNK_SIZE = 25;
 function validateWranglerEnvName(env) {
 	if (env.includes("\0")) throw new Error("Wrangler environment names cannot contain null bytes.");
 	return env;
@@ -295,21 +371,25 @@ function buildWranglerDeployArgs(options) {
 		env
 	};
 }
-function buildWranglerKVBulkPutArgs(options) {
-	const env = options.env || void 0;
-	const args = [
-		"kv",
-		"bulk",
-		"put",
-		options.filePath,
-		"--binding",
-		options.binding,
-		"--remote"
-	];
-	if (env) args.push("--env", validateWranglerEnvName(env));
+function resolveDeploymentTool(root) {
+	return fs.existsSync(path.join(root, "cloudflare.config.ts")) ? "cf" : "wrangler";
+}
+function isCfCliInstalled(root, resolvePackageJson = (projectRoot) => {
+	try {
+		return createRequire(path.join(projectRoot, "package.json")).resolve("cf/package.json");
+	} catch {
+		return findInNodeModules(projectRoot, "cf/package.json");
+	}
+}) {
+	return resolvePackageJson(root) !== null;
+}
+function buildCfDeployArgs(options) {
+	const mode = options.env || (options.preview ? "preview" : void 0);
+	const args = ["deploy", "--prebuilt"];
+	if (mode) args.push("--mode", validateWranglerEnvName(mode));
 	return {
 		args,
-		env
+		mode
 	};
 }
 /**
@@ -333,6 +413,21 @@ function resolveWranglerBin(root, resolvePackageJson = (projectRoot) => {
 	}
 	return path.join(root, "node_modules", "wrangler", "bin", "wrangler.js");
 }
+function resolveCfBin(root, resolvePackageJson = (projectRoot) => {
+	try {
+		return createRequire(path.join(projectRoot, "package.json")).resolve("cf/package.json");
+	} catch {
+		return findInNodeModules(projectRoot, "cf/package.json");
+	}
+}) {
+	const packageJsonPath = resolvePackageJson(root);
+	if (packageJsonPath) {
+		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+		const bin = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.cf;
+		if (bin) return path.resolve(path.dirname(packageJsonPath), bin);
+	}
+	return path.join(root, "node_modules", "cf", "bin", "cf");
+}
 function buildNodeCliInvocation(scriptPath, args, nodeExecutable = process.execPath) {
 	return {
 		file: nodeExecutable,
@@ -347,46 +442,8 @@ function buildWranglerInvocation(root, options, nodeExecutable = process.execPat
 		env
 	};
 }
-async function runWranglerKVBulkPut(root, options, execute = spawn, nodeExecutable = process.execPath) {
-	const tempDir = fs.mkdtempSync(path.join(options.tempDir ?? os.tmpdir(), "vinext-kv-bulk-"));
-	try {
-		const wranglerBin = resolveWranglerBin(root);
-		const totalChunks = Math.ceil(options.pairs.length / KV_BULK_PUT_CHUNK_SIZE);
-		for (let i = 0; i < totalChunks; i++) {
-			const filePath = path.join(tempDir, `prerender-kv-${i}.json`);
-			const chunk = options.pairs.slice(i * KV_BULK_PUT_CHUNK_SIZE, (i + 1) * KV_BULK_PUT_CHUNK_SIZE);
-			fs.writeFileSync(filePath, JSON.stringify(chunk), "utf-8");
-			const { args } = buildWranglerKVBulkPutArgs({
-				binding: options.binding,
-				env: options.env,
-				filePath
-			});
-			const invocation = buildNodeCliInvocation(wranglerBin, args, nodeExecutable);
-			const child = execute(invocation.file, invocation.args, {
-				cwd: root,
-				stdio: "inherit",
-				shell: false
-			});
-			await new Promise((resolve, reject) => {
-				child.once("error", reject);
-				child.once("close", (code, signal) => {
-					if (code === 0) {
-						resolve();
-						return;
-					}
-					const exitReason = signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`;
-					reject(/* @__PURE__ */ new Error(`Wrangler KV bulk put failed with ${exitReason}.`));
-				});
-			});
-		}
-	} finally {
-		fs.rmSync(tempDir, {
-			recursive: true,
-			force: true
-		});
-	}
-}
 async function runWranglerDeploy(root, options, execute = spawn) {
+	if (options.promote === false) return runWranglerVersionUpload(root, options).previewUrl ?? "(Preview URL not detected in wrangler output)";
 	const spawnOptions = {
 		cwd: root,
 		stdio: [
@@ -424,12 +481,95 @@ async function runWranglerDeploy(root, options, execute = spawn) {
 	});
 	return parseWorkerDeploymentUrl(output) ?? "(URL not detected in wrangler output)";
 }
+async function runCfDeploy(root, options, execute = spawn) {
+	const { args, mode } = buildCfDeployArgs(options);
+	console.log(mode ? `\n  Deploying Build Output in mode: ${mode}...` : "\n  Deploying Build Output...");
+	const child = execute(process.execPath, [resolveCfBin(root), ...args], {
+		cwd: root,
+		stdio: [
+			"inherit",
+			"pipe",
+			"pipe"
+		],
+		shell: false
+	});
+	let output = "";
+	child.stdout?.on("data", (chunk) => {
+		const text = chunk.toString();
+		output += text;
+		process.stdout.write(text);
+	});
+	child.stderr?.on("data", (chunk) => {
+		const text = chunk.toString();
+		output += text;
+		process.stderr.write(text);
+	});
+	await new Promise((resolve, reject) => {
+		child.once("error", reject);
+		child.once("close", (code, signal) => {
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`cf deploy failed with ${signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`}.`));
+		});
+	});
+	return parseWorkerDeploymentUrl(output) ?? "(URL not detected in cf output)";
+}
 function hasCdnWarmRequests(plan) {
 	return plan.paths.length + (plan.pagesDataPaths?.length ?? 0) + (plan.routeHandlerPaths?.length ?? 0) + plan.rscPaths.length + plan.loadingShellPaths.length > 0;
 }
+function selectTPRWarmPlan(plan, traffic, coverage, limit) {
+	const canonical = (pathname) => normalizePathTrailingSlash(pathname, false);
+	const resolved = new Set(Object.entries(plan.routePatterns ?? {}).map(([pathname, route]) => canonical(route.cacheabilityProbe?.concretePathname ?? pathname)));
+	const requestsByPath = /* @__PURE__ */ new Map();
+	for (const { path, requests } of traffic) {
+		const pathname = canonical(path);
+		if (!resolved.has(pathname)) continue;
+		requestsByPath.set(pathname, (requestsByPath.get(pathname) ?? 0) + requests);
+	}
+	const selected = new Set(selectRoutes(Array.from(requestsByPath, ([path, requests]) => ({
+		path,
+		requests
+	})).sort((a, b) => b.requests - a.requests), coverage, limit).routes.map(({ path }) => path));
+	const includes = (pathname) => selected.has(canonical(plan.routePatterns?.[pathname]?.cacheabilityProbe?.concretePathname ?? pathname));
+	const filter = (pathnames) => pathnames?.filter(includes);
+	return {
+		...plan,
+		appPaths: filter(plan.appPaths),
+		loadingShellPaths: filter(plan.loadingShellPaths) ?? [],
+		pagesDataPaths: filter(plan.pagesDataPaths),
+		pagesPaths: filter(plan.pagesPaths),
+		paths: filter(plan.paths) ?? [],
+		routeHandlerPaths: filter(plan.routeHandlerPaths),
+		routePatterns: plan.routePatterns ? Object.fromEntries(Object.entries(plan.routePatterns).filter(([pathname]) => includes(pathname))) : void 0,
+		rscPaths: filter(plan.rscPaths) ?? []
+	};
+}
 function projectRequiresRouteCacheabilityProbeManifest(project, cacheConfig) {
 	return (project.isAppRouter || project.isPagesRouter) && requiresRouteCacheabilityProbeManifest(cacheConfig);
 }
+function deploymentWorkerName(options) {
+	if (!options.name) throw new Error("Could not detect the Worker name for its deployment.");
+	return options.name;
+}
+function runDeploymentStatus(root, options) {
+	return options.deploymentTool === "cf" ? runCfDeploymentStatus(root, {
+		name: deploymentWorkerName(options),
+		env: options.env,
+		verbose: options.verbose
+	}) : runWranglerDeploymentStatus(root, options);
+}
+function runVersionDeploy(root, traffic, options, phase) {
+	return options.deploymentTool === "cf" ? runCfVersionDeploy(root, traffic, {
+		name: deploymentWorkerName(options),
+		env: options.env,
+		verbose: options.verbose
+	}, phase) : runWranglerVersionDeploy(root, traffic, options, phase);
+}
+function runTriggersDeploy(root, options) {
+	return options.deploymentTool === "cf" ? runCfTriggersDeploy(root, options) : runWranglerTriggersDeploy(root, options);
+}
+function runVersionUpload(root, options) {
+	return options.deploymentTool === "cf" ? runCfVersionUpload(root, options) : runWranglerVersionUpload(root, options);
+}
 function cdnWarmTargetKey(target) {
 	return `${target.kind}\0${target.sourcePathname}`;
 }
@@ -449,14 +589,14 @@ async function deployWithCdnWarmup(root, paths, options) {
 		...options,
 		warmCdnTarget: validateCdnWarmTarget(options.warmCdnTarget)
 	};
-	if (options.warmCdnDiscoveryTimeout !== void 0) parsePositiveIntegerArg(String(options.warmCdnDiscoveryTimeout), "--warm-cdn-discovery-timeout");
-	if (options.warmCdnDiscoveryRetries !== void 0) parseNonNegativeIntegerArg(String(options.warmCdnDiscoveryRetries), "--warm-cdn-discovery-retries");
-	if (options.warmCdnProbeTimeout !== void 0) parsePositiveIntegerArg(String(options.warmCdnProbeTimeout), "--warm-cdn-probe-timeout");
-	if (options.warmCdnProbeRetries !== void 0) parseNonNegativeIntegerArg(String(options.warmCdnProbeRetries), "--warm-cdn-probe-retries");
-	if (options.warmCdnReadinessTimeout !== void 0) parsePositiveIntegerArg(String(options.warmCdnReadinessTimeout), "--warm-cdn-readiness-timeout");
-	if (options.warmCdnReadinessRetries !== void 0) parseNonNegativeIntegerArg(String(options.warmCdnReadinessRetries), "--warm-cdn-readiness-retries");
-	if (options.warmCdnReadinessProbes !== void 0) parsePositiveIntegerArg(String(options.warmCdnReadinessProbes), "--warm-cdn-readiness-probes");
-	if (options.warmCdnReadinessProbeDelay !== void 0) validateTimerDelay(options.warmCdnReadinessProbeDelay, "--warm-cdn-readiness-probe-delay");
+	if (options.warmCdnDiscoveryTimeout !== void 0) parsePositiveIntegerArg(String(options.warmCdnDiscoveryTimeout), "--warm-cache-discovery-timeout");
+	if (options.warmCdnDiscoveryRetries !== void 0) parseNonNegativeIntegerArg(String(options.warmCdnDiscoveryRetries), "--warm-cache-discovery-retries");
+	if (options.warmCdnProbeTimeout !== void 0) parsePositiveIntegerArg(String(options.warmCdnProbeTimeout), "--warm-cache-probe-timeout");
+	if (options.warmCdnProbeRetries !== void 0) parseNonNegativeIntegerArg(String(options.warmCdnProbeRetries), "--warm-cache-probe-retries");
+	if (options.warmCdnReadinessTimeout !== void 0) parsePositiveIntegerArg(String(options.warmCdnReadinessTimeout), "--warm-cache-readiness-timeout");
+	if (options.warmCdnReadinessRetries !== void 0) parseNonNegativeIntegerArg(String(options.warmCdnReadinessRetries), "--warm-cache-readiness-retries");
+	if (options.warmCdnReadinessProbes !== void 0) parsePositiveIntegerArg(String(options.warmCdnReadinessProbes), "--warm-cache-readiness-probes");
+	if (options.warmCdnReadinessProbeDelay !== void 0) validateTimerDelay(options.warmCdnReadinessProbeDelay, "--warm-cache-readiness-probe-delay");
 	if (options.warmCdnPromotionDelay !== void 0) validatePromotionDelay(options.warmCdnPromotionDelay);
 	if (options.cacheabilityProbe) return deployWithCacheabilityProbe(root, options);
 	return deployUploadedVersionWithCdnWarmup(root, paths, options);
@@ -481,7 +621,7 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 		if (plan.paths.length === 0 && plan.pagesDataPaths.length === 0 && (plan.routeHandlerPaths?.length ?? 0) === 0 || expectedBuildId !== void 0) return plan;
 		if (!allowUnverifiedPromotion) {
 			const warmupKind = plan.paths.length > 0 ? "CDN HTML warmup" : plan.pagesDataPaths.length > 0 ? "CDN Pages data warmup" : "CDN Route Handler warmup";
-			throw new Error(`${warmupKind} requires a CDN adapter that declares build-identity response headers. Configure that adapter capability or deploy without --experimental-warm-cdn-cache.`);
+			throw new Error(`${warmupKind} requires a CDN adapter that declares build-identity response headers. Configure that adapter capability or deploy without --warm-cache.`);
 		}
 		console.warn(`  CDN warmup: skipping ${plan.paths.length} HTML, ${plan.pagesDataPaths.length} Pages data, and ${plan.routeHandlerPaths?.length ?? 0} Route Handler request(s) because the CDN adapter does not declare build-identity response headers.`);
 		return {
@@ -493,10 +633,11 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 	};
 	const discoverWarmPlan = async (targetUrl, headers) => {
 		if (!options.discoverWarmPlan) return;
-		const plan = await options.discoverWarmPlan({
+		const discovered = await options.discoverWarmPlan({
 			headers,
 			targetUrl
 		});
+		const plan = options.selectWarmPlan?.(discovered) ?? discovered;
 		deploymentId = plan.deploymentId;
 		expectedBuildId = plan.buildIdentity;
 		expectedRscBuildId = plan.rscBuildId;
@@ -512,7 +653,8 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 		warmPlanDiscovered = true;
 	};
 	if (!options.discoverWarmPlan || hasPreparedWarmPlan) remainingWarmPlan = prepareWarmPlan(remainingWarmPlan);
-	const upload = options.uploadedVersion ?? runWranglerVersionUpload(root, options);
+	const upload = options.uploadedVersion ?? runVersionUpload(root, options);
+	const wranglerOptions = resolveDeploymentControlPlaneOptions(options, upload);
 	const warmUploadedVersion = (targetUrl, headers, propagatingTarget = false, plan = {
 		loadingShellPaths: remainingWarmPlan.loadingShellPaths,
 		pagesDataPaths: remainingWarmPlan.pagesDataPaths,
@@ -541,11 +683,17 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 		strict: requireCacheHit || !allowUnverifiedPromotion,
 		statusSource: options.statusSource
 	});
-	const wranglerConfig = parseWranglerConfig(root, options.config);
-	const deploymentStatus = runWranglerDeploymentStatus(root, options);
-	if (options.expectedDeploymentState && !deploymentStateEquals(deploymentStatus, options.expectedDeploymentState)) throw new Error("Two-stage CDN warming stopped because Worker deployment traffic or deployment identity changed before the final version could be staged. No final version was promoted.");
+	const wranglerConfig = options.deploymentTool === "cf" ? null : parseWranglerConfig(root, options.config);
+	let deploymentStatus;
+	try {
+		deploymentStatus = runDeploymentStatus(root, wranglerOptions);
+	} catch (error) {
+		if (!hasPreparedWarmPlan) throw error;
+		throw new StagedWarmupError(formatUnknownError(error), { cause: error });
+	}
+	if (options.expectedDeploymentState && !deploymentStateEquals(deploymentStatus, options.expectedDeploymentState)) throw new StagedWarmupError("Two-stage CDN warming stopped because Worker deployment traffic or deployment identity changed before the final version could be staged. No final version was promoted.");
 	const stagingTraffic = getZeroPercentStagingTraffic(deploymentStatus, upload.versionId);
-	if (hasPreparedWarmPlan && !stagingTraffic) throw new Error("Two-stage CDN warming stopped because Worker deployment traffic changed before the final version could be staged. No final version was promoted.");
+	if (hasPreparedWarmPlan && !stagingTraffic) throw new StagedWarmupError("Two-stage CDN warming stopped because Worker deployment traffic changed before the final version could be staged. No final version was promoted.");
 	let staged = null;
 	let triggersDeployedUrl = options.triggersDeployedUrl ?? null;
 	let stagedCacheFilled = false;
@@ -554,14 +702,14 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 	let triggersApplied = options.triggersAlreadyApplied === true;
 	function applyTriggers() {
 		if (triggersApplied) return;
-		triggersDeployedUrl = runWranglerTriggersDeploy(root, options).deployedUrl;
+		triggersDeployedUrl = runTriggersDeploy(root, wranglerOptions).deployedUrl;
 		triggersApplied = true;
 	}
 	if (stagingTraffic) {
 		try {
-			staged = runWranglerVersionDeploy(root, stagingTraffic, options, "stage");
+			staged = runVersionDeploy(root, stagingTraffic, wranglerOptions, "stage");
 		} catch (error) {
-			throw reconcileVersionDeployFailure(root, options, error, {
+			throw reconcileVersionDeployFailure(root, wranglerOptions, error, {
 				desiredTraffic: stagingTraffic,
 				desiredDescription: "The uploaded version is staged at 0% with the previous version still serving 100% traffic; Worker triggers/routes were not changed.",
 				priorState: deploymentStatus,
@@ -570,7 +718,7 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 		}
 		try {
 			if (hasPreparedWarmPlan) {
-				stagedDeploymentState = runWranglerDeploymentStatus(root, options);
+				stagedDeploymentState = runDeploymentStatus(root, wranglerOptions);
 				if (!deploymentTrafficEquals(stagedDeploymentState.versions, stagingTraffic)) throw new Error("Two-stage CDN warming stopped because Worker deployment traffic changed before production triggers could be applied. No final version was promoted.");
 			}
 			applyTriggers();
@@ -578,7 +726,7 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 			throw withStagedVersionCleanupNote(error);
 		}
 		const targetUrl = resolveCdnWarmupTargetUrl(root, triggersDeployedUrl, options) ?? staged.deployedUrl;
-		const headers = buildVersionOverrideHeaders(options.name ?? upload.workerName ?? resolveWorkerNameForVersionOverride(wranglerConfig, options), upload.versionId);
+		const headers = buildVersionOverrideHeaders(options.name ?? upload.workerName ?? resolveWorkerNameForVersionOverride(wranglerConfig, wranglerOptions), upload.versionId);
 		if (targetUrl && headers) try {
 			if (!warmPlanDiscovered) {
 				console.log("  CDN warmup: discovering paths from the staged Worker version...");
@@ -620,7 +768,7 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 					console.log("  CDN warmup: staged Worker version is stable.");
 					const warmResult = await warmUploadedVersion(targetUrl, headers, true, stagedWarmPlan);
 					const optionalSkipped = options.optionalWarmTargetKeys ? warmResult.skippedTargets.filter((target) => options.optionalWarmTargetKeys.has(cdnWarmTargetKey(target))).length : 0;
-					if (hasPreparedWarmPlan && options.warmCdnCertify) {
+					if ((hasPreparedWarmPlan || options.selectWarmPlan) && options.warmCdnCertify) {
 						if (warmResult.warmed + optionalSkipped !== stagedWarmRequests) throw new Error(`CDN warmup cannot certify the staged cache because only ${warmResult.warmed}/${stagedWarmRequests - optionalSkipped} cacheable entries completed their initial fill.`);
 					}
 					const requiredSkipped = warmResult.skipped - optionalSkipped;
@@ -637,7 +785,7 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 						routeHandlerPaths: warmResult.retryPlan.routeHandlerPaths,
 						rscPaths: warmResult.retryPlan.rscPaths
 					};
-					if (hasPreparedWarmPlan && options.warmCdnCertify && warmResult.warmed > 0) {
+					if (options.warmCdnCertify && warmResult.warmed > 0) {
 						console.log(`  CDN warmup: certifying ${warmResult.warmed} staged cache entr${warmResult.warmed === 1 ? "y" : "ies"} before promotion...`);
 						const certification = await warmUploadedVersion(targetUrl, headers, true, warmResult.warmedPlan, true);
 						if (certification.warmed !== warmResult.warmed) throw new Error(`CDN warmup certified ${certification.warmed}/${warmResult.warmed} staged cache entries as reusable.`);
@@ -649,8 +797,8 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 			throw withStagedVersionCleanupNote(error);
 		}
 		else if (initialWarmRequests > 0) {
-			const message = "CDN warmup failed: pre-traffic warmup needs a production URL and Worker name for version overrides. Configure a route/custom domain and Worker name, or deploy without --experimental-warm-cdn-cache.";
-			if (!allowUnverifiedPromotion) throw new Error(`${message} ${getStagedVersionCleanupNote()}`);
+			const message = "CDN warmup failed: pre-traffic warmup needs a production URL and Worker name for version overrides. Configure a route/custom domain and Worker name, or deploy without --warm-cache.";
+			if (!allowUnverifiedPromotion) throw new StagedWarmupError(`${message} ${getStagedVersionCleanupNote()}`);
 			console.warn(`  ${message} Promoting because the dangerous override is enabled.`);
 		}
 	} else {
@@ -661,23 +809,26 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 		}
 		console.warn("  CDN warmup: pre-traffic version override skipped because the current deployment is not one version serving 100% traffic.");
 	}
+	if (options.selectWarmPlan && options.warmCdnCertify && !stagedCacheFilled) {
+		const error = /* @__PURE__ */ new Error("CDN warmup cannot succeed because no cache entries were certified.");
+		throw staged ? withStagedVersionCleanupNote(error) : error;
+	}
 	const countRemainingWarmRequests = () => remainingWarmPlan.paths.length + remainingWarmPlan.pagesDataPaths.length + (remainingWarmPlan.routeHandlerPaths?.length ?? 0) + remainingWarmPlan.rscPaths.length + remainingWarmPlan.loadingShellPaths.length;
 	if (options.warmCdnPromote === false) {
 		if (!staged) throw new Error("CDN warmup cannot skip promotion because the uploaded Worker version could not be staged at 0% traffic. The current deployment must have exactly one version serving 100% traffic.");
 		const remainingWarmRequests = countRemainingWarmRequests();
-		if (!hasPreparedWarmPlan && options.discoverWarmPlan && discoveredWarmRequests === 0) throw withStagedVersionCleanupNote(/* @__PURE__ */ new Error("CDN warmup cannot skip promotion because no build-discovered requests were found to warm."));
+		if (!options.allowEmptyWarmPlan && !hasPreparedWarmPlan && options.discoverWarmPlan && discoveredWarmRequests === 0) throw withStagedVersionCleanupNote(/* @__PURE__ */ new Error("CDN warmup cannot skip promotion because no build-discovered requests were found to warm."));
 		if (remainingWarmRequests > 0) throw withStagedVersionCleanupNote(/* @__PURE__ */ new Error(`CDN warmup cannot skip promotion because ${remainingWarmRequests} request(s) remain unwarmed.`));
 		if (hasPreparedWarmPlan && stagedDeploymentState) {
 			let currentDeployment;
 			try {
-				currentDeployment = runWranglerDeploymentStatus(root, options);
+				currentDeployment = runDeploymentStatus(root, wranglerOptions);
 			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				throw new Error(`${message} CDN warmup cannot confirm that the uploaded Worker remains staged at 0% traffic; production Worker triggers/routes remain applied. Inspect \`wrangler deployments status\` before continuing.`, { cause: error });
+				throw new StagedWarmupError(`${error instanceof Error ? error.message : String(error)} CDN warmup cannot confirm that the uploaded Worker remains staged at 0% traffic; production Worker triggers/routes remain applied. Inspect the active Worker deployment before continuing.`, { cause: error });
 			}
-			if (!deploymentStateEquals(currentDeployment, stagedDeploymentState)) throw new Error("Two-stage CDN warming stopped because Worker deployment traffic or deployment identity changed before the no-promote handoff. The uploaded Worker is not confirmed staged at 0% traffic; production Worker triggers/routes remain applied.");
+			if (!deploymentStateEquals(currentDeployment, stagedDeploymentState)) throw new StagedWarmupError("Two-stage CDN warming stopped because Worker deployment traffic or deployment identity changed before the no-promote handoff. The uploaded Worker is not confirmed staged at 0% traffic; production Worker triggers/routes remain applied.");
 		}
-		console.log("  CDN warmup: promotion disabled; uploaded Worker version remains staged at 0% traffic and production Worker triggers/routes remain applied.");
+		console.log(`  CDN warmup: promotion disabled; uploaded Worker version ${upload.versionId} remains staged at 0% traffic and production Worker triggers/routes remain applied.`);
 		return staged.deployedUrl ?? triggersDeployedUrl ?? upload.previewUrl ?? "(URL not detected in wrangler output)";
 	}
 	let deployed;
@@ -696,13 +847,13 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 			}
 		}
 		if (hasPreparedWarmPlan && stagingTraffic) {
-			prePromotionState = runWranglerDeploymentStatus(root, options);
+			prePromotionState = runDeploymentStatus(root, wranglerOptions);
 			if (!deploymentTrafficEquals(prePromotionState.versions, stagingTraffic) || stagedDeploymentState && !deploymentStateEquals(prePromotionState, stagedDeploymentState)) throw new Error("Two-stage CDN warming stopped because Worker deployment traffic or deployment identity changed before the final version could be promoted. No final version was promoted.");
 		}
 		promotionAttempted = true;
-		deployed = runWranglerVersionDeploy(root, promotionTraffic, options, stagedCacheFilled ? "promote-warmed" : "promote-uploaded");
+		deployed = runVersionDeploy(root, promotionTraffic, wranglerOptions, stagedCacheFilled ? "promote-warmed" : "promote-uploaded");
 	} catch (error) {
-		if (promotionAttempted) throw reconcileVersionDeployFailure(root, options, error, {
+		if (promotionAttempted) throw reconcileVersionDeployFailure(root, wranglerOptions, error, {
 			desiredTraffic: promotionTraffic,
 			desiredDescription: "The uploaded version is already promoted to 100%; Worker triggers/routes may already have changed.",
 			priorState: prePromotionState ?? (stagingTraffic ? {
@@ -734,7 +885,7 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 		} catch (error) {
 			throw withPromotedVersionWarmupNote(error);
 		}
-		else if (!allowUnverifiedPromotion) throw withPromotedVersionWarmupNote(/* @__PURE__ */ new Error("CDN warmup failed: no production URL could be inferred from wrangler config or output. Configure a route/custom domain, ensure Wrangler prints a workers.dev URL, or deploy without --experimental-warm-cdn-cache."));
+		else if (!allowUnverifiedPromotion) throw withPromotedVersionWarmupNote(/* @__PURE__ */ new Error("CDN warmup failed: no production URL could be inferred from wrangler config or output. Configure a route/custom domain, ensure Wrangler prints a workers.dev URL, or deploy without --warm-cache."));
 		else console.warn("  CDN warmup skipped: no production URL could be inferred after promotion; the dangerous override was enabled.");
 	}
 	return deployed.deployedUrl ?? triggersDeployedUrl ?? staged?.deployedUrl ?? upload.previewUrl ?? "(URL not detected in wrangler output)";
@@ -752,31 +903,36 @@ function deploymentStateEquals(actual, expected) {
 function reconcileVersionDeployFailure(root, options, error, expected) {
 	const message = error instanceof Error ? error.message : String(error);
 	let reconciliation;
+	let mayNeedCleanup = true;
 	try {
-		const current = runWranglerDeploymentStatus(root, options);
+		const current = runDeploymentStatus(root, options);
 		if (deploymentTrafficEquals(current.versions, expected.desiredTraffic)) reconciliation = expected.desiredDescription;
-		else if (deploymentStateEquals(current, expected.priorState)) reconciliation = expected.priorDescription;
-		else reconciliation = "Worker deployment state differs from both the requested and prior state, so the deployment outcome is unknown or another deployment changed it.";
+		else if (deploymentStateEquals(current, expected.priorState)) {
+			reconciliation = expected.priorDescription;
+			mayNeedCleanup = false;
+		} else reconciliation = "Worker deployment state differs from both the requested and prior state, so the deployment outcome is unknown or another deployment changed it.";
 	} catch (reconciliationError) {
 		reconciliation = `Worker deployment status could not be read after the command failed, so the deployment outcome is unknown (${reconciliationError instanceof Error ? reconciliationError.message : String(reconciliationError)}).`;
 	}
-	return new Error(`${message} ${reconciliation}`, { cause: error });
+	const detail = `${message} ${reconciliation}`;
+	return mayNeedCleanup ? new StagedWarmupError(detail, { cause: error }) : new Error(detail, { cause: error });
 }
 function assertDeploymentStateUnchanged(root, options, expected, message) {
-	if (!deploymentStateEquals(runWranglerDeploymentStatus(root, options), expected)) throw new Error(message);
+	if (!deploymentStateEquals(runDeploymentStatus(root, options), expected)) throw new Error(message);
 }
 async function deployWithCacheabilityProbe(root, options) {
 	if (!options.discoverWarmPlan) throw new Error("Two-stage CDN warming requires staged Worker route discovery before cacheability probing.");
 	const prerenderSecret = readPrerenderSecret(root);
-	const probeUpload = runWranglerVersionUpload(root, options);
-	const initialDeployment = runWranglerDeploymentStatus(root, options);
+	const probeUpload = runVersionUpload(root, options);
+	const wranglerOptions = resolveDeploymentControlPlaneOptions(options, probeUpload);
+	const initialDeployment = runDeploymentStatus(root, wranglerOptions);
 	const probeTraffic = getZeroPercentStagingTraffic(initialDeployment, probeUpload.versionId);
 	if (!probeTraffic) throw new Error("Two-stage CDN warming cannot stage the probe Worker at 0% because the current deployment is not exactly one version serving 100% traffic. No traffic or triggers were changed.");
 	let stagedProbe;
 	try {
-		stagedProbe = runWranglerVersionDeploy(root, probeTraffic, options, "stage");
+		stagedProbe = runVersionDeploy(root, probeTraffic, wranglerOptions, "stage");
 	} catch (error) {
-		throw reconcileVersionDeployFailure(root, options, error, {
+		throw reconcileVersionDeployFailure(root, wranglerOptions, error, {
 			desiredTraffic: probeTraffic,
 			desiredDescription: "The probe version is staged at 0% with the previous version still serving 100% traffic; production Worker triggers/routes were not changed.",
 			priorState: initialDeployment,
@@ -785,17 +941,16 @@ async function deployWithCacheabilityProbe(root, options) {
 	}
 	let stagedProbeDeployment;
 	try {
-		stagedProbeDeployment = runWranglerDeploymentStatus(root, options);
+		stagedProbeDeployment = runDeploymentStatus(root, wranglerOptions);
 		if (!deploymentTrafficEquals(stagedProbeDeployment.versions, probeTraffic)) throw new Error("Two-stage CDN warming stopped because Worker deployment traffic changed immediately after the probe version was staged.");
 	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`${message} The probe staging command completed, but its current deployment state could not be confirmed; production Worker triggers/routes were not changed. Inspect \`wrangler deployments status\` and remove the staged probe version if necessary.`, { cause: error });
+		throw new StagedWarmupError(`${error instanceof Error ? error.message : String(error)} The probe staging command completed, but its current deployment state could not be confirmed; production Worker triggers/routes were not changed. Inspect the active Worker deployment and remove the staged probe version if necessary.`, { cause: error });
 	}
 	let prepared;
 	try {
 		const targetUrl = resolveCdnWarmupTargetUrl(root, stagedProbe.deployedUrl ?? probeUpload.previewUrl, options);
-		const wranglerConfig = parseWranglerConfig(root, options.config);
-		const headers = buildVersionOverrideHeaders(options.name ?? probeUpload.workerName ?? resolveWorkerNameForVersionOverride(wranglerConfig, options), probeUpload.versionId);
+		const wranglerConfig = options.deploymentTool === "cf" ? null : parseWranglerConfig(root, wranglerOptions.config);
+		const headers = buildVersionOverrideHeaders(options.name ?? probeUpload.workerName ?? resolveWorkerNameForVersionOverride(wranglerConfig, wranglerOptions), probeUpload.versionId);
 		if (!targetUrl || !headers) throw new Error("Two-stage CDN warming needs a production URL and Worker name for version-overridden cacheability probes.");
 		console.log("  CDN warmup: discovering paths from the staged probe Worker...");
 		const discovered = await options.discoverWarmPlan({
@@ -861,6 +1016,7 @@ async function deployWithCacheabilityProbe(root, options) {
 				concurrency: options.warmCdnConcurrency,
 				expectedResponseBuildId: plan.buildIdentity,
 				fallbackRoutePatterns: plan.fallbackRoutePatterns,
+				loadingBoundaryRoutePatterns: plan.loadingBoundaryRoutePatterns,
 				phaseTimeoutMs: options.warmCdnProbeTimeout ?? 12e4,
 				retries: options.warmCdnProbeRetries ?? options.warmCdnRetries ?? 2,
 				retryDelayMs: DEFAULT_CACHEABILITY_PROBE_RETRY_DELAY_MS,
@@ -885,19 +1041,17 @@ async function deployWithCacheabilityProbe(root, options) {
 			routeHandlerPaths: probe.cacheableTargets.filter((target) => target.kind === "app-route").map((target) => target.sourcePathname),
 			rscPaths: probe.cacheableTargets.filter((target) => target.kind === "rsc-full").map((target) => target.sourcePathname)
 		};
-		assertDeploymentStateUnchanged(root, options, stagedProbeDeployment, "Two-stage CDN warming stopped because Worker deployment traffic or deployment identity changed while cacheability was being probed. No final version was promoted.");
-		const finalConfig = writeCacheabilityManifestArtifact(root, options.config, probe.manifest);
-		const finalUpload = runWranglerVersionUpload(root, {
-			config: finalConfig,
-			env: options.env,
-			name: options.name,
-			preview: options.preview,
-			verbose: options.verbose
+		const selectedFinalPlan = options.selectWarmPlan?.(finalPlan) ?? finalPlan;
+		assertDeploymentStateUnchanged(root, wranglerOptions, stagedProbeDeployment, "Two-stage CDN warming stopped because Worker deployment traffic or deployment identity changed while cacheability was being probed. No final version was promoted.");
+		const finalConfig = writeCacheabilityManifestArtifact(root, options.config, probe.manifest, options.deploymentTool);
+		const finalUpload = runVersionUpload(root, {
+			...options,
+			config: options.deploymentTool === "cf" ? options.config : finalConfig
 		});
 		prepared = {
 			optionalWarmTargetKeys: new Set(probe.speculativeTargets.map(cdnWarmTargetKey)),
 			prerenderSecret,
-			plan: finalPlan,
+			plan: selectedFinalPlan,
 			upload: finalUpload
 		};
 	} catch (error) {
@@ -934,6 +1088,15 @@ function getZeroPercentStagingTraffic(deployment, versionId) {
 function getWranglerTargetEnv(options) {
 	return options.env || (options.preview ? "preview" : void 0);
 }
+function resolveDeploymentControlPlaneOptions(options, upload) {
+	if (options.deploymentTool !== "cf") return options;
+	const name = upload.workerName ?? options.name;
+	if (!name) throw new Error("Could not detect the uploaded Worker name needed for staged CDN warming.");
+	return {
+		...options,
+		name
+	};
+}
 function resolveWorkerNameForVersionOverride(config, options) {
 	if (options.name) return options.name;
 	const env = getWranglerTargetEnv(options);
@@ -952,32 +1115,35 @@ function buildVersionOverrideHeaders(workerName, versionId) {
 	};
 }
 function withStagedVersionCleanupNote(error) {
-	const message = error instanceof Error ? error.message : String(error);
-	return new Error(`${message} ${getStagedVersionCleanupNote()}`, { cause: error });
+	return new StagedWarmupError(`${error instanceof Error ? error.message : String(error)} ${getStagedVersionCleanupNote()}`, { cause: error });
 }
 function withStagedProbeVersionCleanupNote(error) {
-	const message = error instanceof Error ? error.message : String(error);
-	return new Error(`${message} The probe version may remain staged at 0% with the previous version still serving 100% traffic; production Worker triggers/routes were not changed.`, { cause: error });
+	return new StagedWarmupError(`${error instanceof Error ? error.message : String(error)} The probe version may remain staged at 0% with the previous version still serving 100% traffic; production Worker triggers/routes were not changed.`, { cause: error });
 }
 function getStagedVersionCleanupNote() {
-	return "The uploaded version may remain staged at 0% with the previous version still serving 100% traffic; Worker triggers/routes may also have changed because trigger deployment runs before warming. Rerun deploy to promote it or use `wrangler versions deploy` to choose the desired version split.";
+	return "The uploaded version may remain staged at 0% with the previous version still serving 100% traffic; Worker triggers/routes may also have changed because trigger deployment runs before warming. Rerun deploy to promote it or create a deployment with the desired version split.";
 }
 function withPromotedVersionTriggerNote(error) {
 	const message = error instanceof Error ? error.message : String(error);
-	return new Error(`${message} The uploaded version may already be promoted to 100%, but Worker triggers/routes may not be updated; rerun deploy or \`wrangler triggers deploy\` after fixing the trigger error.`, { cause: error });
+	return new Error(`${message} The uploaded version may already be promoted to 100%, but Worker triggers/routes may not be updated; rerun deploy or apply the Worker triggers after fixing the trigger error.`, { cause: error });
 }
 function withPromotedVersionWarmupNote(error) {
 	const message = error instanceof Error ? error.message : String(error);
-	return new Error(`${message} The uploaded version is already promoted to 100% and its Worker triggers/routes were updated; rerun deploy to retry cache warming or roll back with \`wrangler versions deploy\`.`, { cause: error });
+	return new Error(`${message} The uploaded version is already promoted to 100% and its Worker triggers/routes were updated; rerun deploy to retry cache warming or create a deployment for the previous version.`, { cause: error });
 }
 async function deploy(options) {
-	if (options.warmCdnTarget !== void 0 && !options.warmCdnCache) throw new Error("--warm-cdn-target requires --experimental-warm-cdn-cache.");
+	if (options.warmCdnTarget !== void 0 && !options.warmCdnCache && !options.experimentalTPR) throw new Error("--warm-cache-target requires --warm-cache or --traffic-aware-warm-cache.");
 	const warmCdnTarget = options.warmCdnTarget === void 0 ? void 0 : validateCdnWarmTarget(options.warmCdnTarget);
-	const deployEnv = validateWranglerEnvName(options.env || (options.preview ? "preview" : "production"));
+	const deployEnv = options.env || (options.preview ? "preview" : void 0);
+	if (deployEnv) validateWranglerEnvName(deployEnv);
 	const root = path.resolve(options.root);
+	const deploymentTool = resolveDeploymentTool(root);
+	if (deploymentTool === "cf" && options.name) throw new Error("--name is not supported for cloudflare.config.ts projects. Set `name` in cloudflare.config.ts instead.");
+	const viteMode = resolveViteBuildMode(deploymentTool, deployEnv);
+	const wranglerFallbackEnv = deploymentTool === "cf" ? void 0 : deployEnv;
 	loadDotenv({
 		root,
-		mode: "production"
+		mode: viteMode
 	});
 	console.log("\n  vinext-cloudflare deploy\n");
 	const info = detectProject(root);
@@ -995,20 +1161,20 @@ async function deploy(options) {
 	if (missingScaffolding.length > 0) throw new Error(`Missing Cloudflare deployment setup: ${missingScaffolding.join(", ")}. Run \`vinext init --platform=cloudflare\` first.`);
 	const missingDeps = getMissingDeps(info);
 	if (missingDeps.length > 0) throw new Error(`Missing deployment dependencies: ${missingDeps.map((dependency) => dependency.name).join(", ")}. Run \`vinext init --platform=cloudflare\` first.`);
+	if (deploymentTool === "cf" && !isCfCliInstalled(root)) throw new Error("Missing deployment dependencies: cf. Run `vinext init --platform=cloudflare` first.");
 	if (info.hasViteConfig && !viteConfigHasCloudflarePlugin(root)) throw new Error(formatMissingCloudflarePluginError({ isAppRouter: info.isAppRouter }));
-	if (info.hasISR && !viteConfigHasCacheAdapter(root) && !workerEntryHasCacheHandler(root)) throw new Error(formatMissingCacheAdapterError({}));
+	if (info.hasISR && !viteConfigHasCacheAdapter(root) && !workerEntryHasCacheHandler(root)) throw new Error(formatMissingCacheAdapterError({ typedConfig: deploymentTool === "cf" }));
 	if (!viteConfigHasImageAdapter(root)) {
 		console.log();
-		console.log(formatImageOptimizationHint());
+		console.log(formatImageOptimizationHint(deploymentTool === "cf"));
 	}
 	if (options.dryRun) {
 		console.log("\n  Dry run complete. No build or deploy performed.\n");
 		return;
 	}
-	const buildEnv = deployEnv === "production" && !options.env ? void 0 : deployEnv;
-	const viteConfigMetadata = await withCloudflareEnv(buildEnv, () => loadDeployViteConfigMetadata(info.root));
+	const viteConfigMetadata = await withCloudflareEnv(deployEnv, () => loadDeployViteConfigMetadata(info.root, viteMode));
 	const cdnAdapterConfig = resolveCdnAdapterConfig(viteConfigMetadata.cacheConfig);
-	const nextConfig = await withCloudflareEnv(buildEnv, async () => {
+	const nextConfig = await withCloudflareEnv(deployEnv, async () => {
 		const inlineNextConfig = viteConfigMetadata.nextConfig;
 		const rawNextConfig = inlineNextConfig ? await resolveNextConfigInput(inlineNextConfig, PHASE_PRODUCTION_BUILD) : await loadNextConfig(info.root, PHASE_PRODUCTION_BUILD);
 		return resolveNextConfig(rawNextConfig, info.root);
@@ -1019,35 +1185,82 @@ async function deploy(options) {
 		vinextPrerenderConfig,
 		nextOutput: nextConfig.output
 	});
+	const shouldPrerenderLocally = Boolean(prerenderDecision && (nextConfig.output === "export" || hasCacheAdapterPrerenderOutput(viteConfigMetadata.cacheConfig)));
 	const hasStrictResponseVary = hasVerbatimResponseVary(viteConfigMetadata.cacheConfig);
-	const hasStagedRequestRouting = hasUncachedRequestRouting(viteConfigMetadata.cacheConfig);
+	const warmupStatusSource = cacheWarmupStatusSource(viteConfigMetadata.cacheConfig);
+	const hasStagedRequestRouting = hasUncachedRequestRouting(viteConfigMetadata.cacheConfig) || warmupStatusSource === "data-cache";
 	const hasBuildIdentityHeader = hasBuildIdentityResponseHeader(viteConfigMetadata.cacheConfig);
 	const hasCanonicalRscWarmup = supportsCanonicalRscWarmup(viteConfigMetadata.cacheConfig);
-	const hasVinextCacheWarmupStatus = usesVinextCacheWarmupStatus(viteConfigMetadata.cacheConfig);
 	const needsCacheabilityProbeManifest = projectRequiresRouteCacheabilityProbeManifest(info, viteConfigMetadata.cacheConfig);
-	const shouldEmitPrerenderPathManifest = !options.skipBuild && prerenderDecision;
-	if (!options.skipBuild) await runBuild(info, buildEnv);
+	const shouldEmitPrerenderPathManifest = !options.skipBuild && shouldPrerenderLocally;
+	if (prerenderDecision && !shouldPrerenderLocally) {
+		const trigger = prerenderDecision.reason === "flag" ? "--prerender-all" : "vinext prerender config";
+		const replacement = options.warmCdnCache ? "Routes will be rendered and warmed through the staged Worker instead." : "Use --warm-cache to render and warm routes through the deployed Worker instead.";
+		console.warn(`\n  Warning: ${trigger} is ignored by Cloudflare deploy. ${replacement}`);
+	}
+	if (!options.skipBuild) await runBuild(info, deployEnv, viteMode);
 	else console.log("\n  Skipping build (--skip-build)");
-	if (options.warmCdnCache && cdnAdapterConfig) {
-		const wrangler = await loadProjectWranglerApi(info.root);
-		const previousCwd = process.cwd();
+	const prerenderOutputDirs = resolvePrerenderOutputDirs(info.root, deploymentTool, viteConfigMetadata.routeRootConfig);
+	const canWarmTpr = options.experimentalTPR && !shouldPrerenderLocally && hasBuildIdentityHeader;
+	if (options.experimentalTPR && shouldPrerenderLocally) console.log("  TPR: Skipping route selection (all-route prerendering configured)");
+	else if (options.experimentalTPR && !hasBuildIdentityHeader) console.log(workerEntryHasCacheHandler(root) ? "  TPR: Skipping pre-warm (legacy imperative cache handlers must migrate to declarative vinext({ cache }) for standard warming)" : "  TPR: Skipping pre-warm (configured cache does not expose build identity)");
+	const tpr = canWarmTpr ? await resolveTPRRoutes({
+		root,
+		config: options.config,
+		env: wranglerFallbackEnv,
+		hostname: warmCdnTarget ? new URL(warmCdnTarget).hostname : void 0,
+		typedConfig: deploymentTool === "cf",
+		window: Math.max(1, options.tprWindow ?? 24)
+	}) : null;
+	if (tpr?.skipped) console.log(`  TPR: Skipped (${tpr.skipped})`);
+	const tprRoutes = tpr?.routes ?? [];
+	const wranglerOptions = {
+		env: deploymentTool === "cf" ? viteMode : deployEnv,
+		name: deploymentTool === "cf" ? readBuildOutputWorkerName(root) : options.name,
+		config: options.config,
+		verbose: options.verbose,
+		deploymentTool
+	};
+	let shouldWarmTpr = tprRoutes.length > 0;
+	if (shouldWarmTpr && !options.warmCdnCache) {
 		try {
-			process.chdir(info.root);
-			const config = wrangler.unstable_readConfig({
-				config: options.config,
-				env: buildEnv
-			}, {
-				hideWarnings: true,
-				preserveOriginalMain: true,
-				useRedirectIfAvailable: true
-			});
-			assertCdnVersionMetadataConfig({
-				binding: cdnAdapterConfig.versionMetadataBinding,
-				configuredBinding: config.version_metadata?.binding,
-				configPath: config.configPath
-			});
-		} finally {
-			process.chdir(previousCwd);
+			shouldWarmTpr = getZeroPercentStagingTraffic(runDeploymentStatus(root, wranglerOptions), "tpr-preflight") !== null;
+		} catch {
+			shouldWarmTpr = false;
+		}
+		if (!shouldWarmTpr) console.log("  TPR: Skipping pre-warm (current deployment cannot be staged safely)");
+	}
+	const shouldWarmCdnCache = options.warmCdnCache || shouldWarmTpr;
+	if (options.warmCdnCertify && !shouldWarmCdnCache) throw new Error("Cannot certify traffic-aware warming because pre-warming was skipped.");
+	const shouldSelectTpr = shouldWarmTpr && !options.warmCdnCache;
+	const candidatePathsOnly = shouldSelectTpr && !needsCacheabilityProbeManifest;
+	if (shouldWarmCdnCache && cdnAdapterConfig) {
+		if (deploymentTool === "cf") {
+			const configPath = path.join(root, ".cloudflare/output/v0/workers/default/worker.config.json");
+			const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+			const binding = cdnAdapterConfig.versionMetadataBinding;
+			if (config.env?.[binding]?.type !== "version-metadata") throw new Error(`[vinext] Cloudflare CDN warmup requires version metadata binding ${JSON.stringify(binding)} in the generated Build Output Worker config ${configPath}.`);
+		} else {
+			const wrangler = await loadProjectWranglerApi(info.root);
+			const previousCwd = process.cwd();
+			try {
+				process.chdir(info.root);
+				const config = wrangler.unstable_readConfig({
+					config: options.config,
+					env: wranglerFallbackEnv
+				}, {
+					hideWarnings: true,
+					preserveOriginalMain: true,
+					useRedirectIfAvailable: true
+				});
+				assertCdnVersionMetadataConfig({
+					binding: cdnAdapterConfig.versionMetadataBinding,
+					configuredBinding: config.version_metadata?.binding,
+					configPath: config.configPath
+				});
+			} finally {
+				process.chdir(previousCwd);
+			}
 		}
 	}
 	if (shouldEmitPrerenderPathManifest) await emitPrerenderPathManifest({
@@ -1057,100 +1270,102 @@ async function deploy(options) {
 		requestRouting: hasStagedRequestRouting ? "uncached-stage" : void 0,
 		responseVary: hasStrictResponseVary ? "verbatim" : void 0,
 		isResponsePolicyHeader: (name) => isConfiguredCdnResponsePolicyHeader(viteConfigMetadata.cacheConfig, name),
-		routeRootConfig: viteConfigMetadata.routeRootConfig
+		routeRootConfig: prerenderOutputDirs
 	});
-	let ranPrerender = false;
-	if (prerenderDecision) {
+	let prerenderResult = void 0;
+	if (shouldPrerenderLocally && prerenderDecision) {
 		console.log(`\n  ${formatVinextPrerenderLabel(prerenderDecision)}`);
 		if (nextConfig.enablePrerenderSourceMaps) {
 			process.setSourceMapsEnabled(true);
 			Error.stackTraceLimit = Math.max(Error.stackTraceLimit, 50);
 		}
-		await runPrerender({
+		prerenderResult = await runPrerender({
 			root: info.root,
-			concurrency: options.prerenderConcurrency,
+			concurrency: options.prerenderConcurrency ?? viteConfigMetadata.prerenderConfig?.concurrency,
 			nextConfig,
-			routeRootConfig: viteConfigMetadata.routeRootConfig
+			routeRootConfig: prerenderOutputDirs
+		});
+		if (nextConfig.output !== "export") await finalizeCacheAdapterPrerenderOutput(viteConfigMetadata.cacheConfig, info.root, { clientOutDir: prerenderOutputDirs?.clientOutDir });
+	}
+	if (!options.skipBuild) {
+		await printBuildReport({
+			root: info.root,
+			pageExtensions: nextConfig.pageExtensions,
+			prerenderResult: prerenderResult ?? void 0
 		});
-		ranPrerender = true;
+		console.log("\n  Build complete.\n");
 	}
-	if (ranPrerender) try {
-		await populateKVCacheFromPrerenderedArtifacts(root, deployEnv === "production" && !options.env ? void 0 : deployEnv, viteConfigMetadata.cacheConfig);
+	let url;
+	if (shouldWarmCdnCache) try {
+		url = await deployWithCdnWarmup(root, [], {
+			...wranglerOptions,
+			allowEmptyWarmPlan: tprRoutes.length > 0 && !options.warmCdnCache,
+			cacheabilityProbe: needsCacheabilityProbeManifest,
+			discoverWarmPlan: async ({ headers, targetUrl }) => {
+				const discovery = await discoverPrerenderPathManifest({
+					root: info.root,
+					candidatePaths: tprRoutes.map(({ path }) => path),
+					candidatePathsOnly,
+					nextConfig,
+					buildIdentity: hasBuildIdentityHeader ? "response-header" : void 0,
+					includeCanonicalRsc: hasCanonicalRscWarmup,
+					requestRouting: hasStagedRequestRouting ? "uncached-stage" : void 0,
+					responseVary: hasStrictResponseVary ? "verbatim" : void 0,
+					isResponsePolicyHeader: (name) => isConfiguredCdnResponsePolicyHeader(viteConfigMetadata.cacheConfig, name),
+					routeRootConfig: viteConfigMetadata.routeRootConfig,
+					pathDiscoveryTarget: {
+						baseUrl: targetUrl,
+						headers,
+						phaseTimeoutMs: options.warmCdnDiscoveryTimeout ?? DEFAULT_REMOTE_PATH_DISCOVERY_PHASE_TIMEOUT_MS,
+						retries: options.warmCdnDiscoveryRetries,
+						retryDelayMs: DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS
+					}
+				});
+				if (!discovery) return {
+					loadingShellPaths: [],
+					paths: [],
+					rscPaths: []
+				};
+				return createPrerenderWarmPlan(root, discovery, {
+					includeCanonicalRsc: hasCanonicalRscWarmup,
+					includeFallbackShells: options.warmCdnIncludeFallbacks,
+					strict: options.warmCdnCertify === true || !options.dangerouslyPromoteOnCdnWarmError
+				});
+			},
+			selectWarmPlan: shouldSelectTpr ? (plan) => selectTPRWarmPlan(plan, tprRoutes, Math.max(1, Math.min(100, options.tprCoverage ?? 90)), Math.max(1, options.tprLimit ?? 1e3)) : void 0,
+			statusSource: warmupStatusSource,
+			warmCdnConcurrency: options.warmCdnConcurrency,
+			warmCdnTarget: warmCdnTarget ?? tpr?.targetUrl,
+			warmCdnTimeout: options.warmCdnTimeout,
+			warmCdnRetries: options.warmCdnRetries,
+			warmCdnDiscoveryTimeout: options.warmCdnDiscoveryTimeout,
+			warmCdnDiscoveryRetries: options.warmCdnDiscoveryRetries,
+			warmCdnProbeTimeout: options.warmCdnProbeTimeout,
+			warmCdnProbeRetries: options.warmCdnProbeRetries,
+			warmCdnCertify: options.warmCdnCertify,
+			warmCdnReadinessTimeout: options.warmCdnReadinessTimeout,
+			warmCdnReadinessRetries: options.warmCdnReadinessRetries,
+			warmCdnReadinessProbes: options.warmCdnReadinessProbes,
+			warmCdnReadinessProbeDelay: options.warmCdnReadinessProbeDelay,
+			dangerouslyPromoteOnCdnWarmError: options.dangerouslyPromoteOnCdnWarmError,
+			warmCdnPromote: options.warmCdnPromote,
+			warmCdnPromotionDelay: options.warmCdnPromotionDelay
+		});
 	} catch (error) {
-		console.log(`  KV cache: Skipping prerender upload (${formatUnknownError(error)}). Continuing with deploy.`);
+		if (options.warmCdnCache || options.warmCdnCertify || options.warmCdnPromote === false && error instanceof StagedWarmupError) throw error;
+		console.log(`  TPR: Skipping pre-warm (${formatUnknownError(error)}). Continuing with deploy.`);
 	}
-	if (options.experimentalTPR) {
-		console.log();
-		const tprResult = await runTPR({
-			root,
-			config: options.config,
-			coverage: Math.max(1, Math.min(100, options.tprCoverage ?? 90)),
-			limit: Math.max(1, options.tprLimit ?? 1e3),
-			window: Math.max(1, options.tprWindow ?? 24)
+	if (url === void 0) {
+		if (deploymentTool === "cf" && options.warmCdnPromote === false) url = runCfVersionUpload(root, wranglerOptions).previewUrl ?? "(Preview URL not detected in cf output)";
+		else if (deploymentTool === "cf") url = await runCfDeploy(root, wranglerOptions);
+		else url = await runWranglerDeploy(root, {
+			...wranglerOptions,
+			promote: options.warmCdnPromote
 		});
-		if (tprResult.skipped) console.log(`  TPR: Skipped (${tprResult.skipped})`);
 	}
-	const wranglerOptions = {
-		env: deployEnv === "production" && !options.env ? void 0 : deployEnv,
-		name: options.name,
-		config: options.config,
-		verbose: options.verbose
-	};
-	let url;
-	if (options.warmCdnCache) url = await deployWithCdnWarmup(root, [], {
-		...wranglerOptions,
-		cacheabilityProbe: needsCacheabilityProbeManifest,
-		discoverWarmPlan: async ({ headers, targetUrl }) => {
-			const discovery = await discoverPrerenderPathManifest({
-				root: info.root,
-				nextConfig,
-				buildIdentity: hasBuildIdentityHeader ? "response-header" : void 0,
-				includeCanonicalRsc: hasCanonicalRscWarmup,
-				requestRouting: hasStagedRequestRouting ? "uncached-stage" : void 0,
-				responseVary: hasStrictResponseVary ? "verbatim" : void 0,
-				isResponsePolicyHeader: (name) => isConfiguredCdnResponsePolicyHeader(viteConfigMetadata.cacheConfig, name),
-				routeRootConfig: viteConfigMetadata.routeRootConfig,
-				pathDiscoveryTarget: {
-					baseUrl: targetUrl,
-					headers,
-					phaseTimeoutMs: options.warmCdnDiscoveryTimeout ?? DEFAULT_REMOTE_PATH_DISCOVERY_PHASE_TIMEOUT_MS,
-					retries: options.warmCdnDiscoveryRetries,
-					retryDelayMs: DEFAULT_REMOTE_PATH_DISCOVERY_RETRY_DELAY_MS
-				}
-			});
-			if (!discovery) return {
-				loadingShellPaths: [],
-				paths: [],
-				rscPaths: []
-			};
-			return createPrerenderWarmPlan(root, discovery, {
-				includeCanonicalRsc: hasCanonicalRscWarmup,
-				includeFallbackShells: options.warmCdnIncludeFallbacks,
-				strict: options.warmCdnCertify === true || !options.dangerouslyPromoteOnCdnWarmError
-			});
-		},
-		statusSource: hasVinextCacheWarmupStatus ? "vinext" : "cloudflare",
-		warmCdnConcurrency: options.warmCdnConcurrency,
-		warmCdnTarget,
-		warmCdnTimeout: options.warmCdnTimeout,
-		warmCdnRetries: options.warmCdnRetries,
-		warmCdnDiscoveryTimeout: options.warmCdnDiscoveryTimeout,
-		warmCdnDiscoveryRetries: options.warmCdnDiscoveryRetries,
-		warmCdnProbeTimeout: options.warmCdnProbeTimeout,
-		warmCdnProbeRetries: options.warmCdnProbeRetries,
-		warmCdnCertify: options.warmCdnCertify,
-		warmCdnReadinessTimeout: options.warmCdnReadinessTimeout,
-		warmCdnReadinessRetries: options.warmCdnReadinessRetries,
-		warmCdnReadinessProbes: options.warmCdnReadinessProbes,
-		warmCdnReadinessProbeDelay: options.warmCdnReadinessProbeDelay,
-		dangerouslyPromoteOnCdnWarmError: options.dangerouslyPromoteOnCdnWarmError,
-		warmCdnPromote: options.warmCdnPromote,
-		warmCdnPromotionDelay: options.warmCdnPromotionDelay
-	});
-	else url = await runWranglerDeploy(root, wranglerOptions);
 	console.log("\n  ─────────────────────────────────────────");
-	console.log(`  Deployed to: ${url}`);
+	console.log(`  ${options.warmCdnPromote === false ? "Version URL" : "Deployed to"}: ${url}`);
 	console.log("  ─────────────────────────────────────────\n");
 }
 //#endregion
-export { DEFAULT_CDN_WARM_PROMOTION_DELAY_MS, buildNodeCliInvocation, buildVersionOverrideHeaders, buildWranglerDeployArgs, buildWranglerInvocation, buildWranglerKVBulkPutArgs, deploy, deployWithCdnWarmup, getZeroPercentStagingTraffic, hasCdnWarmRequests, parseDeployArgs, projectRequiresRouteCacheabilityProbeManifest, resolveCdnWarmupTargetUrl, resolveWorkerNameForVersionOverride, resolveWranglerBin, runWranglerDeploy, runWranglerKVBulkPut, validateWranglerEnvName, withCloudflareEnv };
+export { DEFAULT_CDN_WARM_PROMOTION_DELAY_MS, buildCfDeployArgs, buildNodeCliInvocation, buildVersionOverrideHeaders, buildWranglerDeployArgs, buildWranglerInvocation, deploy, deployWithCdnWarmup, getZeroPercentStagingTraffic, hasCdnWarmRequests, isCfCliInstalled, parseDeployArgs, projectRequiresRouteCacheabilityProbeManifest, resolveCdnWarmupTargetUrl, resolveCfBin, resolveDeploymentControlPlaneOptions, resolveDeploymentTool, resolvePrerenderOutputDirs, resolveViteBuildMode, resolveWorkerNameForVersionOverride, resolveWranglerBin, runCfDeploy, runWranglerDeploy, selectTPRWarmPlan, validateWranglerEnvName, withCloudflareEnv };