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

package/dist/deploy.js

@@ -7,7 +7,7 @@ import { VINEXT_EXPECTED_WORKER_VERSION_HEADER } from "./version-headers.js";
 import { formatImageOptimizationHint, formatMissingCacheAdapterError, resolveCdnAdapterConfig, resolveKvDataAdapterConfig, 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 { readBuildOutputWorkerName, runCfDeploymentStatus, runCfTriggersDeploy, runCfVersionDeploy, runCfVersionUpload, runWranglerDeploymentStatus, runWranglerTriggersDeploy, runWranglerVersionDeploy, runWranglerVersionUpload } from "./version-deploy.js";
 import { buildPrerenderKVPairs } from "./prerender-kv-populate.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
@@ -20,7 +20,9 @@ import os from "node:os";
 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 { cacheWarmupStatusSource, findVinextCacheConfigInPlugins, findVinextPrerenderConfigInPlugins, findVinextRouteRootConfigInPlugins, formatVinextPrerenderLabel, hasBuildIdentityResponseHeader, hasUncachedRequestRouting, hasVerbatimResponseVary, isConfiguredCdnResponsePolicyHeader, requiresRouteCacheabilityProbeManifest, resolveVinextPrerenderDecision, supportsCanonicalRscWarmup } from "vinext/internal/config/prerender";
@@ -256,10 +258,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),
@@ -268,14 +273,23 @@ 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();
+		const invocation = { onComplete() {
+			completed = true;
+		} };
+		await (await createBuilder({
+			root: info.root,
+			mode,
+			[VINEXT_BUILD_LIFECYCLE_CONFIG]: invocation
+		})).buildApp();
 	});
+	if (!completed) throw new Error("[vinext] The Cloudflare build lifecycle did not complete.");
 }
-async function populateKVCacheFromPrerenderedArtifacts(root, wranglerEnv, cacheConfig) {
+async function populateKVCacheFromPrerenderedArtifacts(root, deploymentTool, env, cacheConfig) {
 	const kvConfig = resolveKvDataAdapterConfig(cacheConfig);
 	if (!kvConfig) return;
 	const { routeCount, pairs } = buildPrerenderKVPairs(path.join(root, "dist", "server"), {
@@ -286,9 +300,10 @@ async function populateKVCacheFromPrerenderedArtifacts(root, wranglerEnv, cacheC
 		console.log("  KV cache: Skipping prerender upload (no App Router prerendered cache entries found).");
 		return;
 	}
-	await runWranglerKVBulkPut(root, {
+	await runKVBulkPut(root, {
 		binding: kvConfig.binding,
-		env: wranglerEnv,
+		deploymentTool,
+		env,
 		pairs
 	});
 	console.log(`  KV cache: Uploaded ${pairs.length} entr${pairs.length === 1 ? "y" : "ies"} for ${routeCount} prerendered route${routeCount === 1 ? "" : "s"}.`);
@@ -309,6 +324,27 @@ function buildWranglerDeployArgs(options) {
 		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,
+		mode
+	};
+}
 function buildWranglerKVBulkPutArgs(options) {
 	const env = options.env || void 0;
 	const args = [
@@ -347,6 +383,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,
@@ -361,21 +412,35 @@ function buildWranglerInvocation(root, options, nodeExecutable = process.execPat
 		env
 	};
 }
-async function runWranglerKVBulkPut(root, options, execute = spawn, nodeExecutable = process.execPath) {
+async function runKVBulkPut(root, options, execute = spawn, nodeExecutable = process.execPath) {
+	const cfNamespaceId = (() => {
+		if (options.deploymentTool !== "cf") return void 0;
+		const configPath = path.join(root, ".cloudflare/output/v0/workers/default/worker.config.json");
+		const binding = JSON.parse(fs.readFileSync(configPath, "utf8")).env?.[options.binding];
+		if (binding?.type !== "kv" || typeof binding.id !== "string" || !binding.id) throw new Error(`[vinext] Generated Cloudflare Build Output does not declare KV binding ${JSON.stringify(options.binding)} with a namespace ID.`);
+		return binding.id;
+	})();
 	const tempDir = fs.mkdtempSync(path.join(options.tempDir ?? os.tmpdir(), "vinext-kv-bulk-"));
 	try {
-		const wranglerBin = resolveWranglerBin(root);
+		const cliBin = cfNamespaceId ? resolveCfBin(root) : 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({
+			const invocation = buildNodeCliInvocation(cliBin, cfNamespaceId ? [
+				"kv",
+				"bulk",
+				"update",
+				cfNamespaceId,
+				"--body",
+				`@${filePath}`,
+				...options.env ? ["--mode", validateWranglerEnvName(options.env)] : []
+			] : buildWranglerKVBulkPutArgs({
 				binding: options.binding,
 				env: options.env,
 				filePath
-			});
-			const invocation = buildNodeCliInvocation(wranglerBin, args, nodeExecutable);
+			}).args, nodeExecutable);
 			const child = execute(invocation.file, invocation.args, {
 				cwd: root,
 				stdio: "inherit",
@@ -389,7 +454,7 @@ async function runWranglerKVBulkPut(root, options, execute = spawn, nodeExecutab
 						return;
 					}
 					const exitReason = signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`;
-					reject(/* @__PURE__ */ new Error(`Wrangler KV bulk put failed with ${exitReason}.`));
+					reject(/* @__PURE__ */ new Error(`${cfNamespaceId ? "cf" : "Wrangler"} KV bulk upload failed with ${exitReason}.`));
 				});
 			});
 		}
@@ -439,6 +504,38 @@ 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;
 }
@@ -472,6 +569,30 @@ function selectTPRWarmPlan(plan, traffic, coverage, limit) {
 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}`;
 }
@@ -555,7 +676,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,
@@ -584,10 +706,10 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 		strict: requireCacheHit || !allowUnverifiedPromotion,
 		statusSource: options.statusSource
 	});
-	const wranglerConfig = parseWranglerConfig(root, options.config);
+	const wranglerConfig = options.deploymentTool === "cf" ? null : parseWranglerConfig(root, options.config);
 	let deploymentStatus;
 	try {
-		deploymentStatus = runWranglerDeploymentStatus(root, options);
+		deploymentStatus = runDeploymentStatus(root, wranglerOptions);
 	} catch (error) {
 		if (!hasPreparedWarmPlan) throw error;
 		throw new StagedWarmupError(formatUnknownError(error), { cause: error });
@@ -603,14 +725,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,
@@ -619,7 +741,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();
@@ -627,7 +749,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...");
@@ -719,9 +841,9 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 		if (hasPreparedWarmPlan && stagedDeploymentState) {
 			let currentDeployment;
 			try {
-				currentDeployment = runWranglerDeploymentStatus(root, options);
+				currentDeployment = runDeploymentStatus(root, wranglerOptions);
 			} catch (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 \`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 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.");
 		}
@@ -744,13 +866,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 ? {
@@ -802,7 +924,7 @@ function reconcileVersionDeployFailure(root, options, error, expected) {
 	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;
@@ -815,20 +937,21 @@ function reconcileVersionDeployFailure(root, options, error, expected) {
 	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,
@@ -837,16 +960,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) {
-		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 \`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({
@@ -937,14 +1060,11 @@ async function deployWithCacheabilityProbe(root, options) {
 			rscPaths: probe.cacheableTargets.filter((target) => target.kind === "rsc-full").map((target) => target.sourcePathname)
 		};
 		const selectedFinalPlan = options.selectWarmPlan?.(finalPlan) ?? finalPlan;
-		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
+		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)),
@@ -986,6 +1106,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);
@@ -1010,24 +1139,29 @@ function withStagedProbeVersionCleanupNote(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.");
 	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);
@@ -1045,20 +1179,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);
@@ -1076,7 +1210,7 @@ async function deploy(options) {
 	const hasCanonicalRscWarmup = supportsCanonicalRscWarmup(viteConfigMetadata.cacheConfig);
 	const needsCacheabilityProbeManifest = projectRequiresRouteCacheabilityProbeManifest(info, viteConfigMetadata.cacheConfig);
 	const shouldEmitPrerenderPathManifest = !options.skipBuild && prerenderDecision;
-	if (!options.skipBuild) await runBuild(info, buildEnv);
+	if (!options.skipBuild) await runBuild(info, deployEnv, viteMode);
 	else console.log("\n  Skipping build (--skip-build)");
 	const canWarmTpr = options.experimentalTPR && !prerenderDecision && hasBuildIdentityHeader;
 	if (options.experimentalTPR && prerenderDecision) console.log("  TPR: Skipping route selection (all-route prerendering configured)");
@@ -1084,22 +1218,24 @@ async function deploy(options) {
 	const tpr = canWarmTpr ? await resolveTPRRoutes({
 		root,
 		config: options.config,
-		env: buildEnv,
+		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: deployEnv === "production" && !options.env ? void 0 : deployEnv,
-		name: options.name,
+		env: deploymentTool === "cf" ? viteMode : deployEnv,
+		name: deploymentTool === "cf" ? readBuildOutputWorkerName(root) : options.name,
 		config: options.config,
-		verbose: options.verbose
+		verbose: options.verbose,
+		deploymentTool
 	};
 	let shouldWarmTpr = tprRoutes.length > 0;
 	if (shouldWarmTpr && !options.warmCdnCache) {
 		try {
-			shouldWarmTpr = getZeroPercentStagingTraffic(runWranglerDeploymentStatus(root, wranglerOptions), "tpr-preflight") !== null;
+			shouldWarmTpr = getZeroPercentStagingTraffic(runDeploymentStatus(root, wranglerOptions), "tpr-preflight") !== null;
 		} catch {
 			shouldWarmTpr = false;
 		}
@@ -1110,25 +1246,32 @@ async function deploy(options) {
 	const candidatePathsOnly = shouldSelectTpr && !needsCacheabilityProbeManifest;
 	const shouldPrerenderLocally = prerenderDecision && (!shouldWarmCdnCache || prerenderDecision.reason === "next-export");
 	if (shouldWarmCdnCache && cdnAdapterConfig) {
-		const wrangler = await loadProjectWranglerApi(info.root);
-		const previousCwd = process.cwd();
-		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);
+		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({
@@ -1141,22 +1284,31 @@ async function deploy(options) {
 		routeRootConfig: viteConfigMetadata.routeRootConfig
 	});
 	let ranPrerender = false;
-	if (shouldPrerenderLocally) {
+	let prerenderResult = void 0;
+	if (shouldPrerenderLocally && !ranPrerender) {
 		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
 		});
 		ranPrerender = true;
 	}
+	if (!options.skipBuild) {
+		await printBuildReport({
+			root: info.root,
+			pageExtensions: nextConfig.pageExtensions,
+			prerenderResult: prerenderResult ?? void 0
+		});
+		console.log("\n  Build complete.\n");
+	}
 	if (ranPrerender) try {
-		await populateKVCacheFromPrerenderedArtifacts(root, deployEnv === "production" && !options.env ? void 0 : deployEnv, viteConfigMetadata.cacheConfig);
+		await populateKVCacheFromPrerenderedArtifacts(root, deploymentTool, deploymentTool === "cf" ? viteMode : wranglerFallbackEnv, viteConfigMetadata.cacheConfig);
 	} catch (error) {
 		console.log(`  KV cache: Skipping prerender upload (${formatUnknownError(error)}). Continuing with deploy.`);
 	}
@@ -1220,13 +1372,17 @@ async function deploy(options) {
 		if (options.warmCdnCache || options.warmCdnPromote === false && error instanceof StagedWarmupError) throw error;
 		console.log(`  TPR: Skipping pre-warm (${formatUnknownError(error)}). Continuing with deploy.`);
 	}
-	if (url === void 0) url = await runWranglerDeploy(root, {
-		...wranglerOptions,
-		promote: options.warmCdnPromote
-	});
+	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
+		});
+	}
 	console.log("\n  ─────────────────────────────────────────");
 	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, selectTPRWarmPlan, validateWranglerEnvName, withCloudflareEnv };
+export { DEFAULT_CDN_WARM_PROMOTION_DELAY_MS, buildCfDeployArgs, buildNodeCliInvocation, buildVersionOverrideHeaders, buildWranglerDeployArgs, buildWranglerInvocation, buildWranglerKVBulkPutArgs, deploy, deployWithCdnWarmup, getZeroPercentStagingTraffic, hasCdnWarmRequests, isCfCliInstalled, parseDeployArgs, projectRequiresRouteCacheabilityProbeManifest, resolveCdnWarmupTargetUrl, resolveCfBin, resolveDeploymentControlPlaneOptions, resolveDeploymentTool, resolveViteBuildMode, resolveWorkerNameForVersionOverride, resolveWranglerBin, runCfDeploy, runKVBulkPut, runWranglerDeploy, selectTPRWarmPlan, validateWranglerEnvName, withCloudflareEnv };

package/dist/tpr.d.ts

@@ -9,6 +9,8 @@ export type TPROptions = {
   env?: string;
   /** Explicit domain used to resolve the analytics zone, overriding Wrangler routes. */
   hostname?: string;
+  /** Read domains from generated Build Output instead of a Wrangler config. */
+  typedConfig?: boolean;
   /** Analytics lookback window in hours. Default: 24. */
   window: number;
 };