@vinext/cloudflare 1.0.0-beta.7 → 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, readPrerenderWarmPlan, waitForCdnWarmTargetReadiness, warmCdnCache } from "./cdn-warm.js";
-import { parseWranglerConfig, runTPR } from "./tpr.js";
+import { CdnOperationProgress, createCdnWarmTargets, createPrerenderWarmPlan, waitForCdnWarmTargetReadiness, warmCdnCache } from "./cdn-warm.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";
@@ -13,7 +14,8 @@ 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, emitPrerenderPathManifest } from "vinext/internal/build/prerender-paths";
+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, hasVerbatimResponseVary, requiresRouteCacheabilityProbeManifest, resolveVinextPrerenderDecision } 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"])
 	};
 }
 /**
@@ -234,7 +248,8 @@ async function loadProjectWranglerApi(root) {
 	try {
 		wranglerPath = req.resolve("wrangler");
 	} catch {
-		wranglerPath = createRequire(req.resolve("@cloudflare/vite-plugin")).resolve("wrangler");
+		const cloudflarePluginPath = req.resolve("@cloudflare/vite-plugin");
+		wranglerPath = createRequire(cloudflarePluginPath).resolve("wrangler");
 	}
 	return await import(
 		/* @vite-ignore */
@@ -386,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: [
@@ -426,12 +442,50 @@ 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);
 }
 function cdnWarmTargetKey(target) {
 	return `${target.kind}\0${target.sourcePathname}`;
 }
+function requiredCdnWarmTargetKeys(plan, optionalTargetKeys) {
+	const keys = /* @__PURE__ */ new Set([
+		...plan.paths.map((pathname) => `html\0${pathname}`),
+		...plan.pagesDataPaths.map((pathname) => `pages-data\0${pathname}`),
+		...(plan.routeHandlerPaths ?? []).map((pathname) => `app-route\0${pathname}`),
+		...plan.rscPaths.map((pathname) => `rsc-full\0${pathname}`),
+		...plan.loadingShellPaths.map((pathname) => `rsc-loading-shell\0${pathname}`)
+	]);
+	if (optionalTargetKeys) for (const key of optionalTargetKeys) keys.delete(key);
+	return keys;
+}
 async function deployWithCdnWarmup(root, paths, options) {
 	if (options.warmCdnTarget !== void 0) options = {
 		...options,
@@ -481,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;
@@ -524,14 +579,22 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 		concurrency: options.warmCdnConcurrency,
 		timeoutMs: options.warmCdnTimeout,
 		retries: options.warmCdnRetries,
+		retrySkippedTargetKeys: propagatingTarget && hasPreparedWarmPlan ? requiredCdnWarmTargetKeys(plan, options.optionalWarmTargetKeys) : void 0,
 		requireCacheHit,
-		strict: requireCacheHit || !allowUnverifiedPromotion
+		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.");
+	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;
@@ -577,6 +640,7 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 				pagesDataPaths: remainingWarmPlan.pagesDataPaths,
 				paths: remainingWarmPlan.paths,
 				routeHandlerPaths: remainingWarmPlan.routeHandlerPaths,
+				routePatterns: remainingWarmPlan.routePatterns,
 				rscPaths: remainingWarmPlan.rscPaths
 			};
 			const stagedWarmRequests = stagedWarmPlan.paths.length + stagedWarmPlan.pagesDataPaths.length + (stagedWarmPlan.routeHandlerPaths?.length ?? 0) + stagedWarmPlan.rscPaths.length + stagedWarmPlan.loadingShellPaths.length;
@@ -622,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.`);
@@ -635,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 {
@@ -650,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;
@@ -673,7 +736,7 @@ async function deployUploadedVersionWithCdnWarmup(root, paths, options) {
 	}];
 	let promotionAttempted = false;
 	try {
-		if (stagedCacheFilled) {
+		if (stagedCacheFilled && options.statusSource !== "vinext") {
 			const promotionDelay = options.warmCdnPromotionDelay ?? 15e3;
 			if (promotionDelay > 0) {
 				console.log(`  CDN warmup: waiting ${promotionDelay / 1e3} seconds for cache propagation before promotion...`);
@@ -737,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);
@@ -773,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 {
@@ -870,9 +936,11 @@ 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, {
-			config: writeCacheabilityManifestArtifact(root, options.config, probe.manifest),
+			config: finalConfig,
 			env: options.env,
 			name: options.name,
 			preview: options.preview,
@@ -881,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) {
@@ -936,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.";
@@ -994,7 +1060,8 @@ async function deploy(options) {
 	const cdnAdapterConfig = resolveCdnAdapterConfig(viteConfigMetadata.cacheConfig);
 	const nextConfig = await withCloudflareEnv(buildEnv, async () => {
 		const inlineNextConfig = viteConfigMetadata.nextConfig;
-		return resolveNextConfig(inlineNextConfig ? await resolveNextConfigInput(inlineNextConfig, PHASE_PRODUCTION_BUILD) : await loadNextConfig(info.root, PHASE_PRODUCTION_BUILD), info.root);
+		const rawNextConfig = inlineNextConfig ? await resolveNextConfigInput(inlineNextConfig, PHASE_PRODUCTION_BUILD) : await loadNextConfig(info.root, PHASE_PRODUCTION_BUILD);
+		return resolveNextConfig(rawNextConfig, info.root);
 	});
 	const vinextPrerenderConfig = !options.prerenderAll && nextConfig.output !== "export" ? viteConfigMetadata.prerenderConfig : null;
 	const prerenderDecision = resolveVinextPrerenderDecision({
@@ -1003,12 +1070,46 @@ async function deploy(options) {
 		nextOutput: nextConfig.output
 	});
 	const hasStrictResponseVary = hasVerbatimResponseVary(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 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 {
@@ -1034,11 +1135,13 @@ async function deploy(options) {
 		root: info.root,
 		nextConfig,
 		buildIdentity: hasBuildIdentityHeader ? "response-header" : void 0,
+		requestRouting: hasStagedRequestRouting ? "uncached-stage" : void 0,
 		responseVary: hasStrictResponseVary ? "verbatim" : void 0,
+		isResponsePolicyHeader: (name) => isConfiguredCdnResponsePolicyHeader(viteConfigMetadata.cacheConfig, name),
 		routeRootConfig: viteConfigMetadata.routeRootConfig
 	});
 	let ranPrerender = false;
-	if (prerenderDecision) {
+	if (shouldPrerenderLocally) {
 		console.log(`\n  ${formatVinextPrerenderLabel(prerenderDecision)}`);
 		if (nextConfig.enablePrerenderSourceMaps) {
 			process.setSourceMapsEnabled(true);
@@ -1047,7 +1150,8 @@ async function deploy(options) {
 		await runPrerender({
 			root: info.root,
 			concurrency: options.prerenderConcurrency,
-			nextConfig
+			nextConfig,
+			routeRootConfig: viteConfigMetadata.routeRootConfig
 		});
 		ranPrerender = true;
 	}
@@ -1056,68 +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 }) => {
-			await emitPrerenderPathManifest({
-				root: info.root,
-				nextConfig,
-				buildIdentity: hasBuildIdentityHeader ? "response-header" : void 0,
-				responseVary: hasStrictResponseVary ? "verbatim" : void 0,
-				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
-				}
-			});
-			return readPrerenderWarmPlan(root, {
-				includeFallbackShells: options.warmCdnIncludeFallbacks,
-				strict: options.warmCdnCertify === true || !options.dangerouslyPromoteOnCdnWarmError
-			});
-		},
-		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/images/images-optimizer.d.ts

@@ -1,6 +1,6 @@
 //#region src/images/images-optimizer.d.ts
 /** Options accepted by {@link imagesOptimizer}, forwarded to the runtime factory. */
-type ImagesOptimizerOptions = {
+export type ImagesOptimizerOptions = {
   /** Cloudflare Images binding name on the Worker `env`. @default "IMAGES" */
   binding?: string;
 };
@@ -21,9 +21,8 @@ type ImagesOptimizerOptions = {
  *   plugins: [vinext({ images: { optimizer: imagesOptimizer() } })],
  * });
  */
-declare function imagesOptimizer(options?: ImagesOptimizerOptions): {
+export declare function imagesOptimizer(options?: ImagesOptimizerOptions): {
   adapter: string;
   options: ImagesOptimizerOptions | undefined;
 };
-//#endregion
-export { ImagesOptimizerOptions, imagesOptimizer };
+//#endregion

package/dist/prerender-kv-populate.d.ts

@@ -7,13 +7,13 @@
  * KVCacheEntry shape written by KVCacheHandler.set(), and returns Wrangler KV
  * bulk import records for deploy-time upload.
  */
-type KVBulkPair = {
+export type KVBulkPair = {
   key: string;
   value: string;
   expiration_ttl?: number;
   metadata?: Record<string, unknown>;
 };
-declare function buildPrerenderKVPairs(serverDir: string, options?: {
+export declare function buildPrerenderKVPairs(serverDir: string, options?: {
   appPrefix?: string;
   now?: number;
   ttlSeconds?: number;
@@ -21,5 +21,4 @@ declare function buildPrerenderKVPairs(serverDir: string, options?: {
   routeCount: number;
   pairs: KVBulkPair[];
 };
-//#endregion
-export { KVBulkPair, buildPrerenderKVPairs };
+//#endregion

package/dist/prerender-kv-populate.js

@@ -16,7 +16,7 @@ import { getAppRouteOutputPath, getOutputPath, getRscOutputPath } from "vinext/i
 * bulk import records for deploy-time upload.
 */
 /** Default KV expiration TTL used by KVCacheHandler for revalidating entries. */
-const DEFAULT_KV_TTL_SECONDS = 720 * 3600;
+const DEFAULT_KV_TTL_SECONDS = 2592e3;
 function resolveContainedFile(rootDir, relativePath) {
 	const resolvedRoot = path.resolve(rootDir);
 	const resolvedFile = path.resolve(resolvedRoot, relativePath);
@@ -48,7 +48,8 @@ function buildMetadata(tags) {
 	return JSON.stringify(metadata).length <= 1024 ? metadata : void 0;
 }
 function buildPrerenderKVPairs(serverDir, options) {
-	const manifest = readPrerenderManifest(path.join(serverDir, "vinext-prerender.json"));
+	const manifestPath = path.join(serverDir, "vinext-prerender.json");
+	const manifest = readPrerenderManifest(manifestPath);
 	if (!manifest?.buildId || !Array.isArray(manifest.routes)) return {
 		routeCount: 0,
 		pairs: []