@vinext/cloudflare 1.0.0-beta.8 → 1.0.0-beta.9

package/dist/deploy.js

@@ -1,7 +1,8 @@
 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 { assertCdnVersionMetadataConfig } from "./wrangler-version-metadata.js";
@@ -14,6 +15,7 @@ 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 { normalizePathTrailingSlash } from "vinext/shims/url-utils";
 import os from "node:os";
 import { spawn } from "node:child_process";
 import { parseArgs } from "node:util";
@@ -21,7 +23,7 @@ import { pathToFileURL } from "node:url";
 import { runPrerender } from "vinext/internal/build/run-prerender";
 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, findVinextCacheConfigInPlugins, findVinextPrerenderConfigInPlugins, findVinextRouteRootConfigInPlugins, formatVinextPrerenderLabel, hasBuildIdentityResponseHeader, 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
@@ -71,6 +73,7 @@ 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: {
@@ -126,6 +129,10 @@ const deployArgOptions = {
 		type: "boolean",
 		default: false
 	},
+	"no-promote": {
+		type: "boolean",
+		default: false
+	},
 	"warm-cdn-no-promote": {
 		type: "boolean",
 		default: false
@@ -135,6 +142,13 @@ const deployArgOptions = {
 		type: "boolean",
 		default: false
 	},
+	"experimental-traffic-aware-warm-cache": {
+		type: "boolean",
+		default: false
+	},
+	"traffic-aware-coverage": { type: "string" },
+	"traffic-aware-limit": { type: "string" },
+	"traffic-aware-window": { type: "string" },
 	"experimental-tpr": {
 		type: "boolean",
 		default: false
@@ -186,13 +200,13 @@ function parseDeployArgs(args) {
 		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"],
+		warmCdnPromote: !values["no-promote"] && !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"])
+		experimentalTPR: values["experimental-traffic-aware-warm-cache"] || values["experimental-tpr"],
+		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"])
 	};
 }
 /**
@@ -387,6 +401,7 @@ async function runWranglerKVBulkPut(root, options, execute = spawn, nodeExecutab
 	}
 }
 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: [
@@ -427,6 +442,33 @@ async function runWranglerDeploy(root, options, execute = spawn) {
 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);
 }
@@ -493,10 +535,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;
@@ -542,10 +585,16 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 		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.");
+	let deploymentStatus;
+	try {
+		deploymentStatus = runWranglerDeploymentStatus(root, options);
+	} 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;
@@ -637,7 +686,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.`);
@@ -650,7 +699,7 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 		}
 		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()}`);
+			if (!allowUnverifiedPromotion) throw new StagedWarmupError(`${message} ${getStagedVersionCleanupNote()}`);
 			console.warn(`  ${message} Promoting because the dangerous override is enabled.`);
 		}
 	} else {
@@ -665,19 +714,18 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 	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);
 			} 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 \`wrangler deployments status\` 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;
@@ -752,15 +800,19 @@ 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);
 		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);
@@ -788,8 +840,7 @@ async function deployWithCacheabilityProbe(root, options) {
 		stagedProbeDeployment = runWranglerDeploymentStatus(root, options);
 		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 \`wrangler deployments status\` and remove the staged probe version if necessary.`, { cause: error });
 	}
 	let prepared;
 	try {
@@ -885,6 +936,7 @@ 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)
 		};
+		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, {
@@ -897,7 +949,7 @@ async function deployWithCacheabilityProbe(root, options) {
 		prepared = {
 			optionalWarmTargetKeys: new Set(probe.speculativeTargets.map(cdnWarmTargetKey)),
 			prerenderSecret,
-			plan: finalPlan,
+			plan: selectedFinalPlan,
 			upload: finalUpload
 		};
 	} catch (error) {
@@ -952,12 +1004,10 @@ 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.";
@@ -1020,15 +1070,46 @@ async function deploy(options) {
 		nextOutput: nextConfig.output
 	});
 	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);
 	else console.log("\n  Skipping build (--skip-build)");
-	if (options.warmCdnCache && cdnAdapterConfig) {
+	const canWarmTpr = options.experimentalTPR && !prerenderDecision && hasBuildIdentityHeader;
+	if (options.experimentalTPR && prerenderDecision) 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: buildEnv,
+		hostname: warmCdnTarget ? new URL(warmCdnTarget).hostname : void 0,
+		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,
+		config: options.config,
+		verbose: options.verbose
+	};
+	let shouldWarmTpr = tprRoutes.length > 0;
+	if (shouldWarmTpr && !options.warmCdnCache) {
+		try {
+			shouldWarmTpr = getZeroPercentStagingTraffic(runWranglerDeploymentStatus(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;
+	const shouldSelectTpr = shouldWarmTpr && !options.warmCdnCache;
+	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 {
@@ -1060,7 +1141,7 @@ async function deploy(options) {
 		routeRootConfig: viteConfigMetadata.routeRootConfig
 	});
 	let ranPrerender = false;
-	if (prerenderDecision) {
+	if (shouldPrerenderLocally) {
 		console.log(`\n  ${formatVinextPrerenderLabel(prerenderDecision)}`);
 		if (nextConfig.enablePrerenderSourceMaps) {
 			process.setSourceMapsEnabled(true);
@@ -1079,78 +1160,73 @@ async function deploy(options) {
 	} catch (error) {
 		console.log(`  KV cache: Skipping prerender upload (${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)
+	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,
+			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
 		});
-		if (tprResult.skipped) console.log(`  TPR: Skipped (${tprResult.skipped})`);
+	} catch (error) {
+		if (options.warmCdnCache || options.warmCdnPromote === false && error instanceof StagedWarmupError) throw error;
+		console.log(`  TPR: Skipping pre-warm (${formatUnknownError(error)}). Continuing with deploy.`);
 	}
-	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, [], {
+	if (url === void 0) url = await runWranglerDeploy(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
+		promote: options.warmCdnPromote
 	});
-	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, buildNodeCliInvocation, buildVersionOverrideHeaders, buildWranglerDeployArgs, buildWranglerInvocation, buildWranglerKVBulkPutArgs, deploy, deployWithCdnWarmup, getZeroPercentStagingTraffic, hasCdnWarmRequests, parseDeployArgs, projectRequiresRouteCacheabilityProbeManifest, resolveCdnWarmupTargetUrl, resolveWorkerNameForVersionOverride, resolveWranglerBin, runWranglerDeploy, runWranglerKVBulkPut, selectTPRWarmPlan, validateWranglerEnvName, withCloudflareEnv };

package/dist/tpr.d.ts

@@ -1,71 +1,32 @@
+import { parseWranglerConfig } from "./wrangler-config.js";
 //#region src/tpr.d.ts
-/**
- * TPR: Traffic-aware Pre-Rendering
- *
- * Uses Cloudflare zone analytics to determine which pages actually get
- * traffic, and pre-renders only those during deploy. The pre-rendered
- * HTML is uploaded to KV in the same format ISR uses at runtime — no
- * runtime changes needed.
- *
- * Flow:
- *   1. Parse wrangler config to find custom domain and KV namespace
- *   2. Resolve the Cloudflare zone for the custom domain
- *   3. Query zone analytics (GraphQL) for top pages by request count
- *   4. Walk ranked list until coverage threshold is met
- *   5. Start the built production server locally
- *   6. Fetch each hot route to produce HTML
- *   7. Upload pre-rendered HTML to KV (same KVCacheEntry format ISR reads)
- *
- * TPR is an experimental feature enabled via --experimental-tpr. It
- * gracefully skips when no custom domain, no API token, no traffic data,
- * or no KV namespace is configured.
- */
 export type TPROptions = {
   /** Project root directory. */
   root: string;
   /** Wrangler config path, relative to root unless absolute. */
   config?: string;
-  /** Traffic coverage percentage (0–100). Default: 90. */
-  coverage: number;
-  /** Hard cap on number of pages to pre-render. Default: 1000. */
-  limit: number;
+  /** Wrangler environment whose custom domain should be analyzed. */
+  env?: string;
+  /** Explicit domain used to resolve the analytics zone, overriding Wrangler routes. */
+  hostname?: string;
   /** Analytics lookback window in hours. Default: 24. */
   window: number;
 };
-export type TPRResult = {
-  /** Total unique page paths found in analytics. */
-  totalPaths: number;
-  /** Number of pages successfully pre-rendered and uploaded. */
-  prerenderedCount: number;
-  /** Actual traffic coverage achieved (percentage). */
-  coverageAchieved: number;
-  /** Wall-clock duration of the TPR step in milliseconds. */
-  durationMs: number;
+export type TPRRouteResult = {
+  routes: TrafficEntry[];
   /** If TPR was skipped, the reason. */
   skipped?: string;
 };
-type PrerenderResult = {
-  html: string;
-  status: number;
-  headers: Record<string, string>;
+export type TrafficEntry = {
+  path: string;
+  requests: number;
 };
-type WranglerConfig = {
-  accountId?: string;
-  kvNamespaceId?: string;
-  customDomain?: string;
-  name?: string;
-  legacyEnv?: boolean;
-  env?: Record<string, WranglerEnvironmentConfig>;
+export type SelectedRoutes = {
+  routes: TrafficEntry[];
+  totalRequests: number;
+  coveredRequests: number;
+  coveragePercent: number;
 };
-export type WranglerEnvironmentConfig = {
-  customDomain?: string;
-  name?: string;
-};
-/**
- * Parse wrangler config (JSONC or TOML) to extract the fields TPR needs:
- * account_id, VINEXT_KV_CACHE KV namespace ID, and custom domain.
- */
-export declare function parseWranglerConfig(root: string, configPath?: string): WranglerConfig | null;
 /**
  * Generate zone lookup candidates from shortest (2-part) to longest.
  * Tries the most common case first (e.g., "example.com") and progressively
@@ -76,25 +37,17 @@ export declare function parseWranglerConfig(root: string, configPath?: string):
  * "example.com"         → ["example.com"]
  */
 export declare function domainCandidates(domain: string): string[];
-export declare function resolveVinextProdServerPath(root: string): string;
+/** Filter out non-page requests (static assets, API routes, internal routes). */
+export declare function filterTrafficPaths(entries: TrafficEntry[]): TrafficEntry[];
 /**
- * Build KV bulk API pairs from pre-rendered entries.
- *
- * Key format matches the runtime KVCacheHandler exactly:
- *   createKvKeySpace().entryKey(isrCacheKey("app", pathname, buildId) + ":html")
- *   → "cache:app:<buildId>:<pathname>:html"
+ * Walk the ranked traffic list, accumulating request counts until the
+ * coverage target is met or the hard cap is reached.
  */
-export declare function buildTprKVPairs(entries: Map<string, PrerenderResult>, buildId: string | undefined, defaultRevalidateSeconds: number): Array<{
-  key: string;
-  value: string;
-  expiration_ttl: number;
-}>;
+export declare function selectRoutes(traffic: TrafficEntry[], coverageTarget: number, limit: number): SelectedRoutes;
 /**
- * Run the TPR pipeline: query traffic, select routes, pre-render, upload.
- *
- * Designed to be called between the build step and wrangler deploy in the
- * `vinext-cloudflare deploy` pipeline. Gracefully skips (never errors) when
- * the prerequisites aren't met.
+ * Resolve ranked traffic paths. The standard CDN pre-warming flow owns route
+ * matching, coverage selection, rendering, and cache admission.
  */
-export declare function runTPR(options: TPROptions): Promise<TPRResult>;
-//#endregion
+export declare function resolveTPRRoutes(options: TPROptions): Promise<TPRRouteResult>;
+//#endregion
+export { parseWranglerConfig };