@vinext/cloudflare 1.0.0-beta.9 → 1.0.0

package/dist/deploy-help.js

@@ -9,78 +9,81 @@ function formatDeployHelp() {
     - Detects App Router or Pages Router
     - Validates setup from vinext init --platform=cloudflare
     - Builds the project with Vite
-    - Deploys via wrangler
+    - Deploys with cf for typed Cloudflare config projects, or Wrangler otherwise
 
   Options:
     --preview                Deploy to preview environment (same as --env preview)
-    --env <name>             Deploy using wrangler env.<name>
-    --name <name>            Custom Worker name (default: from package.json)
+    --env <name>             Cloudflare mode for typed config; Wrangler environment otherwise
+    --name <name>            Custom Worker name for Wrangler config projects
     --config <path>          Wrangler config path (default: wrangler.jsonc/json/toml)
     --skip-build             Skip the build step (use existing dist/)
     --dry-run                Validate setup without building or deploying
-    --verbose                Print raw output from internal Wrangler commands
+    --verbose                Print raw output from internal Cloudflare CLI commands
     --no-promote             Do not promote the uploaded Worker version to 100%
                              traffic
-    --prerender-all          Pre-render discovered routes after building (future
-                             releases will auto-populate the remote cache)
+    --prerender-all          Deprecated for Worker deployments; use
+                             --warm-cache instead (still honored for static
+                             export and cache adapters that package local
+                             prerender output)
     --prerender-concurrency <count>
-                             Maximum number of routes to pre-render in parallel
-    --experimental-warm-cdn-cache
-                             Upload a Worker version, warm build-discovered paths
-                             through the production URL, then promote it (experimental)
-    --warm-cdn-target <origin>
+                             Maximum parallel routes for local prerendering
+    --warm-cache             Upload a Worker version, warm build-discovered paths
+                             through the production URL, then promote it
+    --warm-cache-target <origin>
                              HTTPS origin to use for discovery, probing, and warming
                              (overrides URLs inferred from Wrangler output)
-    --warm-cdn-concurrency <count>
+                             Also supported with traffic-aware warming
+    --warm-cache-concurrency <count>
                              Maximum number of CDN warmup requests in parallel (default: 25)
-    --warm-cdn-timeout <ms>  Per-request CDN warmup timeout (default: 10000)
-    --warm-cdn-retries <n>   Retries per failed CDN warmup request (default: 1;
+    --warm-cache-timeout <ms>  Per-request CDN warmup timeout (default: 10000)
+    --warm-cache-retries <n>   Retries per failed CDN warmup request (default: 1;
                              staged-version propagation default: 60)
-    --warm-cdn-discovery-timeout <ms>
+    --warm-cache-discovery-timeout <ms>
                              Total staged path-discovery deadline (default: 120000)
-    --warm-cdn-discovery-retries <n>
+    --warm-cache-discovery-retries <n>
                              Optional staged path-discovery retry limit
                              (default: derived from the discovery deadline)
-    --warm-cdn-probe-timeout <ms>
+    --warm-cache-probe-timeout <ms>
                              Abort when cacheability probing makes no progress for
                              this duration (default: 120000)
-    --warm-cdn-probe-retries <n>
+    --warm-cache-probe-retries <n>
                              Cacheability-probe retries (default: 2)
-    --warm-cdn-certify      With --experimental-warm-cdn-cache, re-request warmed
-                             entries using headers only and require every planned
-                             entry to be reusable before promotion
-    --warm-cdn-readiness-timeout <ms>
+    --warm-cache-certify      With either warming mode, re-request warmed
+                             entries using headers only and require reusable hits.
+                             Traffic-aware warming requires every selected entry
+                             to be reusable before promotion
+    --warm-cache-readiness-timeout <ms>
                              Explicit total staged-readiness deadline (default:
                              120000)
-    --warm-cdn-readiness-retries <n>
+    --warm-cache-readiness-retries <n>
                              Staged-readiness retries (default: 60)
-    --warm-cdn-readiness-probes <count>
+    --warm-cache-readiness-probes <count>
                              Consecutive successful staged-readiness probes
                              required before warming (default: 6)
-    --warm-cdn-readiness-probe-delay <ms>
+    --warm-cache-readiness-probe-delay <ms>
                              Delay between staged-readiness probes (default: 1000)
-    --dangerously-promote-on-cdn-warm-error
+    --dangerously-promote-on-warm-cache-error
                              Promote even when ordinary staged warmup cannot be
-                             verified (never bypasses --warm-cdn-certify)
-    --warm-cdn-promotion-delay <ms>
+                             verified (never bypasses --warm-cache-certify)
+    --warm-cache-promotion-delay <ms>
                              Delay before promotion after warmup (default: 15000)
-    --warm-cdn-include-fallbacks
+    --warm-cache-include-fallbacks
                              Also warm PPR fallback-shell placeholder paths
     -h, --help               Show this help
 
-  Experimental:
-    --experimental-traffic-aware-warm-cache
-                                     Select CDN pre-warm routes from traffic
+  Traffic-aware warming:
+    --traffic-aware-warm-cache       Select cache warming routes from traffic
     --traffic-aware-coverage <pct>   Traffic coverage target, 0-100 (default: 90)
     --traffic-aware-limit <count>    Hard cap on selected routes (default: 1000)
     --traffic-aware-window <hours>   Analytics lookback window in hours (default: 24)
 
   Traffic-aware warming uses Cloudflare zone analytics to select the
   highest-traffic routes, then feeds those routes into the same staged CDN
-  pre-warming flow used by --experimental-warm-cdn-cache. It requires a custom
-  domain and a CLOUDFLARE_API_TOKEN with Zone Analytics read permission.
-
-  Legacy --experimental-tpr and --tpr-* aliases remain supported.
+  pre-warming flow used by --warm-cache. It requires a custom
+  domain and a CLOUDFLARE_API_TOKEN with Zone > Analytics > Read and
+  Zone > Zone > Read permissions for that zone.
+  Use --warm-cache-target <origin> to provide the production HTTPS origin
+  manually for traffic-aware analytics selection, discovery, probing, and warming.
 
   Workers Cache automatically uses tiered caching. Warmed entries can therefore
   be reused outside the data center reached by the warmup request after cache
@@ -91,20 +94,22 @@ function formatDeployHelp() {
     vpx @vinext/cloudflare deploy                                      Build and deploy with Vite+
     vp exec vinext-cloudflare deploy                                   Run the locally installed Vite+ bin
     vinext-cloudflare deploy --preview                                 Deploy to a preview URL
-    vinext-cloudflare deploy --env staging                             Deploy using wrangler env.staging
+    vinext-cloudflare deploy --env staging                             Deploy using Cloudflare mode/environment staging
     vinext-cloudflare deploy --config dist/server/wrangler.json        Deploy using a generated Wrangler config
     vinext-cloudflare deploy --dry-run                                 Validate setup without building or deploying
     vinext-cloudflare deploy --name my-app                             Deploy with a custom Worker name
     vinext-cloudflare deploy --no-promote                              Upload a version without changing deployment traffic
-    vinext-cloudflare deploy --experimental-warm-cdn-cache              Warm build-discovered paths during version deploy (experimental)
-    vinext-cloudflare deploy --experimental-warm-cdn-cache --warm-cdn-target https://example.com
+    vinext-cloudflare deploy --warm-cache                               Warm build-discovered paths during version deploy
+    vinext-cloudflare deploy --warm-cache --warm-cache-target https://example.com
                                                                           Warm an explicit production origin
-    vinext-cloudflare deploy --experimental-traffic-aware-warm-cache
+    vinext-cloudflare deploy --traffic-aware-warm-cache
                                                                           Enable traffic-aware warming
-    vinext-cloudflare deploy --experimental-traffic-aware-warm-cache --traffic-aware-coverage 95
+    vinext-cloudflare deploy --traffic-aware-warm-cache --traffic-aware-coverage 95
                                                                           Cover 95% of traffic
-    vinext-cloudflare deploy --experimental-traffic-aware-warm-cache --traffic-aware-limit 500
+    vinext-cloudflare deploy --traffic-aware-warm-cache --traffic-aware-limit 500
                                                                           Cap at 500 routes
+    vinext-cloudflare deploy --traffic-aware-warm-cache --warm-cache-target https://example.com
+                                                                          Select and warm traffic routes for an explicit origin
 `;
 }
 function printDeployHelp() {

package/dist/deploy.d.ts

@@ -1,10 +1,9 @@
 import { CdnWarmOptions, CdnWarmRequestPlan, PrerenderWarmPlan } from "./cdn-warm.js";
 import { parseWranglerConfig } from "./wrangler-config.js";
 import { TrafficEntry } from "./tpr.js";
-import { WranglerDeploymentStatus, WranglerVersionTraffic } from "./version-deploy.js";
-import { KVBulkPair } from "./prerender-kv-populate.js";
+import { WranglerDeploymentStatus, WranglerVersionTraffic, WranglerVersionUploadResult } from "./version-deploy.js";
 import { spawn } from "node:child_process";
-import { VinextCacheConfig } from "vinext/internal/config/prerender";
+import { VinextCacheConfig, VinextRouteRootConfig } from "vinext/internal/config/prerender";
 import { ProjectInfo } from "vinext/internal/utils/project";
 //#region src/deploy.d.ts
 export declare const DEFAULT_CDN_WARM_PROMOTION_DELAY_MS = 15000;
@@ -74,6 +73,9 @@ export type DeployOptions = {
   /** TPR: analytics lookback window in hours (default: 24) */
   tprWindow?: number;
 };
+export type DeploymentTool = "cf" | "wrangler";
+/** The typed cf Vite plugin emits Worker and asset bundles into Build Output. */
+export declare function resolvePrerenderOutputDirs(root: string, deploymentTool: DeploymentTool, configured: VinextRouteRootConfig | null): VinextRouteRootConfig | null;
 export declare function parseDeployArgs(args: string[]): {
   help: boolean;
   preview: boolean;
@@ -121,21 +123,20 @@ export declare function parseDeployArgs(args: string[]): {
  * Passing `undefined` is a no-op; the callback runs with `process.env` untouched.
  */
 export declare function withCloudflareEnv<T>(env: string | undefined, fn: () => Promise<T>): Promise<T>;
+export declare function resolveViteBuildMode(deploymentTool: DeploymentTool, env: string | undefined): string;
 type WranglerDeployArgs = {
   args: string[];
   env: string | undefined;
 };
-type WranglerKVBulkPutArgs = {
+type CfDeployArgs = {
   args: string[];
-  env: string | undefined;
+  mode: string | undefined;
 };
 export declare function validateWranglerEnvName(env: string): string;
 export declare function buildWranglerDeployArgs(options: Pick<DeployOptions, "preview" | "env" | "name" | "config">): WranglerDeployArgs;
-export declare function buildWranglerKVBulkPutArgs(options: {
-  binding: string;
-  env?: string;
-  filePath: string;
-}): WranglerKVBulkPutArgs;
+export declare function resolveDeploymentTool(root: string): DeploymentTool;
+export declare function isCfCliInstalled(root: string, resolvePackageJson?: (root: string) => string | null): boolean;
+export declare function buildCfDeployArgs(options: Pick<DeployOptions, "preview" | "env">): CfDeployArgs;
 /**
  * Resolve Wrangler's JavaScript CLI entrypoint in node_modules.
  *
@@ -143,6 +144,7 @@ export declare function buildWranglerKVBulkPutArgs(options: {
  * shim and command shell that package managers create on Windows.
  */
 export declare function resolveWranglerBin(root: string, resolvePackageJson?: (root: string) => string | null): string;
+export declare function resolveCfBin(root: string, resolvePackageJson?: (root: string) => string | null): string;
 export declare function buildNodeCliInvocation(scriptPath: string, args: string[], nodeExecutable?: string): {
   file: string;
   args: string[];
@@ -152,21 +154,17 @@ export declare function buildWranglerInvocation(root: string, options: Pick<Depl
   args: string[];
   env: string | undefined;
 };
-export declare function runWranglerKVBulkPut(root: string, options: {
-  binding: string;
-  env?: string;
-  pairs: KVBulkPair[];
-  tempDir?: string;
-}, execute?: typeof spawn, nodeExecutable?: string): Promise<void>;
 export declare function runWranglerDeploy(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose"> & {
   promote?: boolean;
 }, execute?: typeof spawn): Promise<string>;
+export declare function runCfDeploy(root: string, options: Pick<DeployOptions, "preview" | "env">, execute?: typeof spawn): Promise<string>;
 export declare function hasCdnWarmRequests(plan: Omit<CdnWarmRequestPlan, "pagesDataPaths"> & {
   pagesDataPaths?: readonly string[];
 }): boolean;
 export declare function selectTPRWarmPlan(plan: PrerenderWarmPlan, traffic: readonly TrafficEntry[], coverage: number, limit: number): PrerenderWarmPlan;
 export declare function projectRequiresRouteCacheabilityProbeManifest(project: Pick<ProjectInfo, "isAppRouter" | "isPagesRouter">, cacheConfig: VinextCacheConfig | null): boolean;
 type CdnWarmDeployOptions = Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose" | "warmCdnTarget" | "warmCdnConcurrency" | "warmCdnTimeout" | "warmCdnRetries" | "warmCdnDiscoveryTimeout" | "warmCdnDiscoveryRetries" | "warmCdnProbeTimeout" | "warmCdnProbeRetries" | "warmCdnCertify" | "warmCdnReadinessTimeout" | "warmCdnReadinessRetries" | "warmCdnReadinessProbes" | "warmCdnReadinessProbeDelay" | "dangerouslyPromoteOnCdnWarmError" | "warmCdnPromote" | "warmCdnPromotionDelay"> & Pick<CdnWarmOptions, "deploymentId" | "expectedBuildId" | "expectedRscBuildId" | "loadingShellPaths" | "pagesDataPaths" | "routeHandlerPaths" | "routePatterns" | "rscPaths" | "statusSource"> & {
+  deploymentTool?: DeploymentTool;
   /** Allow optional route selection to discover no warmable requests. */
   allowEmptyWarmPlan?: boolean;
   /** Probe a staged Worker and upload the resulting manifest as a second version. */
@@ -178,11 +176,15 @@ type CdnWarmDeployOptions = Pick<DeployOptions, "preview" | "env" | "name" | "co
   /** Narrow the final warm requests without changing discovery or probe metadata. */
   selectWarmPlan?: (plan: PrerenderWarmPlan) => PrerenderWarmPlan;
 };
+type DeploymentControlPlaneOptions = Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose"> & {
+  deploymentTool?: DeploymentTool;
+};
 export declare function deployWithCdnWarmup(root: string, paths: readonly string[], options: CdnWarmDeployOptions): Promise<string>;
 export declare function resolveCdnWarmupTargetUrl(root: string, deployedUrl: string | null): string | null;
 export declare function resolveCdnWarmupTargetUrl(root: string, deployedUrl: string | null, options: Pick<DeployOptions, "preview" | "env" | "config" | "warmCdnTarget">): string | null;
 export declare function getZeroPercentStagingTraffic(deployment: WranglerDeploymentStatus | null, versionId: string): WranglerVersionTraffic[] | null;
 type ParsedWranglerConfig = NonNullable<ReturnType<typeof parseWranglerConfig>>;
+export declare function resolveDeploymentControlPlaneOptions(options: DeploymentControlPlaneOptions, upload: Pick<WranglerVersionUploadResult, "workerName">): DeploymentControlPlaneOptions;
 export declare function resolveWorkerNameForVersionOverride(config: ParsedWranglerConfig | null, options: Pick<DeployOptions, "preview" | "env" | "name">): string | undefined;
 export declare function buildVersionOverrideHeaders(workerName: string | undefined, versionId: string): HeadersInit | undefined;
 export declare function deploy(options: DeployOptions): Promise<void>;