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

package/dist/utils/cache-control-metadata.d.ts

@@ -5,7 +5,6 @@
  * so the Cloudflare adapters stay self-contained (these mirror the equivalent
  * helpers in the vinext core).
  */
-declare function isUnknownRecord(value: unknown): value is Record<string, unknown>;
-declare function readCacheControlNumberField(ctx: Record<string, unknown> | undefined, field: string): number | undefined;
-//#endregion
-export { isUnknownRecord, readCacheControlNumberField };
+export declare function isUnknownRecord(value: unknown): value is Record<string, unknown>;
+export declare function readCacheControlNumberField(ctx: Record<string, unknown> | undefined, field: string): number | undefined;
+//#endregion

package/dist/version-deploy.d.ts

@@ -1,22 +1,23 @@
 import { parseWorkersDevUrl } from "./workers-dev-url.js";
 import { DeployOptions } from "./deploy.js";
 import { execFileSync } from "node:child_process";
-
 //#region src/version-deploy.d.ts
-type WranglerVersionUploadResult = {
+export type WranglerVersionUploadResult = {
   versionId: string;
   previewUrl: string | null;
+  workerName: string | null;
   output: string;
 };
-type WranglerVersionDeployResult = {
+export type WranglerVersionDeployResult = {
   deployedUrl: string | null;
   output: string;
 };
-type WranglerVersionTraffic = {
+export type WranglerVersionTraffic = {
   versionId: string;
   percentage: number;
 };
-type WranglerDeploymentStatus = {
+export type WranglerDeploymentStatus = {
+  deploymentId: string | null;
   versions: WranglerVersionTraffic[];
   output: string;
 };
@@ -24,20 +25,48 @@ type WranglerVersionArgs = {
   args: string[];
   env: string | undefined;
 };
-declare function parseVersionId(output: string): string | null;
-declare function parseWranglerVersionUploadOutput(output: string): WranglerVersionUploadResult;
-declare function buildWranglerVersionUploadArgs(options: Pick<DeployOptions, "preview" | "env" | "name" | "config"> & {
+type CfVersionArgs = {
+  args: string[];
+  mode: string | undefined;
+};
+export declare function readBuildOutputWorkerName(root: string): string;
+export declare function parseVersionId(output: string): string | null;
+export declare function parseUploadedWorkerName(output: string): string | null;
+export declare function parseWranglerVersionUploadOutput(output: string): WranglerVersionUploadResult;
+export declare function buildWranglerVersionUploadArgs(options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose"> & {
   previewAlias?: string;
 }): WranglerVersionArgs;
-declare function buildWranglerVersionDeployArgs(versionTraffic: readonly WranglerVersionTraffic[], options: Pick<DeployOptions, "preview" | "env" | "name" | "config">): WranglerVersionArgs;
-declare function buildWranglerDeploymentsStatusArgs(options: Pick<DeployOptions, "preview" | "env" | "name" | "config">): WranglerVersionArgs;
-declare function buildWranglerTriggersDeployArgs(options: Pick<DeployOptions, "preview" | "env" | "name" | "config">): WranglerVersionArgs;
-declare function parseWranglerDeploymentStatusOutput(output: string): WranglerDeploymentStatus;
-declare function runWranglerVersionUpload(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config"> & {
+export declare function buildCfVersionUploadArgs(options: Pick<DeployOptions, "preview" | "env"> & {
+  previewAlias?: string;
+}): CfVersionArgs;
+export declare function buildWranglerVersionDeployArgs(versionTraffic: readonly WranglerVersionTraffic[], options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose">): WranglerVersionArgs;
+export declare function buildWranglerDeploymentsStatusArgs(options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose">): WranglerVersionArgs;
+export declare function buildWranglerTriggersDeployArgs(options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose">): WranglerVersionArgs;
+export declare function parseWranglerDeploymentStatusOutput(output: string): WranglerDeploymentStatus;
+/** The first entry is the deployment currently serving traffic. */
+export declare function parseCfDeploymentStatusOutput(output: string): WranglerDeploymentStatus;
+export declare function runCfDeploymentStatus(root: string, options: {
+  name: string;
+  env?: string;
+  verbose?: boolean;
+}, execute?: typeof execFileSync): WranglerDeploymentStatus;
+export declare function runCfVersionDeploy(root: string, versionTraffic: readonly WranglerVersionTraffic[], options: {
+  name: string;
+  env?: string;
+  verbose?: boolean;
+}, _phase?: "stage" | "promote-warmed" | "promote-uploaded", execute?: typeof execFileSync): WranglerVersionDeployResult;
+export declare function runCfTriggersDeploy(root: string, options: {
+  env?: string;
+  verbose?: boolean;
+}, execute?: typeof execFileSync): WranglerVersionDeployResult;
+export declare function runWranglerVersionUpload(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose"> & {
+  previewAlias?: string;
+}, execute?: typeof execFileSync): WranglerVersionUploadResult;
+export declare function runCfVersionUpload(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose"> & {
   previewAlias?: string;
 }, execute?: typeof execFileSync): WranglerVersionUploadResult;
-declare function runWranglerVersionDeploy(root: string, versionTraffic: readonly WranglerVersionTraffic[], options: Pick<DeployOptions, "preview" | "env" | "name" | "config">, phase?: "stage" | "promote-warmed" | "promote-uploaded", execute?: typeof execFileSync): WranglerVersionDeployResult;
-declare function runWranglerDeploymentStatus(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config">, execute?: typeof execFileSync): WranglerDeploymentStatus;
-declare function runWranglerTriggersDeploy(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config">, execute?: typeof execFileSync): WranglerVersionDeployResult;
+export declare function runWranglerVersionDeploy(root: string, versionTraffic: readonly WranglerVersionTraffic[], options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose">, phase?: "stage" | "promote-warmed" | "promote-uploaded", execute?: typeof execFileSync): WranglerVersionDeployResult;
+export declare function runWranglerDeploymentStatus(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose">, execute?: typeof execFileSync): WranglerDeploymentStatus;
+export declare function runWranglerTriggersDeploy(root: string, options: Pick<DeployOptions, "preview" | "env" | "name" | "config" | "verbose">, execute?: typeof execFileSync): WranglerVersionDeployResult;
 //#endregion
-export { WranglerDeploymentStatus, WranglerVersionDeployResult, WranglerVersionTraffic, WranglerVersionUploadResult, buildWranglerDeploymentsStatusArgs, buildWranglerTriggersDeployArgs, buildWranglerVersionDeployArgs, buildWranglerVersionUploadArgs, parseVersionId, parseWorkersDevUrl, parseWranglerDeploymentStatusOutput, parseWranglerVersionUploadOutput, runWranglerDeploymentStatus, runWranglerTriggersDeploy, runWranglerVersionDeploy, runWranglerVersionUpload };
+export { parseWorkersDevUrl };

package/dist/version-deploy.js

@@ -1,10 +1,26 @@
 import { parseWorkersDevUrl } from "./workers-dev-url.js";
-import { buildNodeCliInvocation, resolveWranglerBin, validateWranglerEnvName } from "./deploy.js";
+import { parseCdnWarmupDeploymentUrl } from "./worker-deployment-url.js";
+import { buildNodeCliInvocation, resolveCfBin, resolveWranglerBin, validateWranglerEnvName } from "./deploy.js";
+import fs from "node:fs";
+import path from "node:path";
 import { execFileSync } from "node:child_process";
+import { stripVTControlCharacters } from "node:util";
 //#region src/version-deploy.ts
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function readBuildOutputWorkerName(root) {
+	const configPath = path.join(root, ".cloudflare", "output", "v0", "workers", "default", "worker.config.json");
+	let config;
+	try {
+		config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+	} catch (cause) {
+		throw new Error("Could not read the generated Cloudflare Build Output config. Rebuild the app before deploying.", { cause });
+	}
+	const name = isRecord(config) ? config.name : void 0;
+	if (typeof name !== "string" || name.length === 0) throw new Error("The generated Cloudflare Build Output config does not declare a Worker name.");
+	return name;
+}
 function parseJsonObject(output) {
 	const trimmed = output.trim();
 	if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return null;
@@ -56,16 +72,24 @@ function findPreviewUrlInUploadJson(parsed) {
 	]);
 }
 function parseVersionId(output) {
-	return output.match(/\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b/)?.[0] ?? null;
+	const versionIdPattern = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}";
+	const labeledVersionId = output.match(new RegExp(`Worker\\s+Version\\s+ID\\s*:\\s*(${versionIdPattern})\\b`, "i"))?.[1];
+	if (labeledVersionId) return labeledVersionId;
+	return output.match(new RegExp(`\\b${versionIdPattern}\\b`))?.[0] ?? null;
+}
+function parseUploadedWorkerName(output) {
+	return stripVTControlCharacters(output).match(/^\s*(?:[│|]\s*)?Uploaded\s+(\S+)\s+\(\d+(?:\.\d+)?\s+sec\)\s*$/im)?.[1] ?? null;
 }
 function parseWranglerVersionUploadOutput(output) {
 	const parsed = parseJsonObject(output);
 	const versionId = findVersionIdInUploadJson(parsed) ?? parseVersionId(output);
 	const previewUrl = findPreviewUrlInUploadJson(parsed) ?? parseWorkersDevUrl(output);
+	const workerName = parseUploadedWorkerName(output);
 	if (!versionId) throw new Error("Could not detect Worker version ID from `wrangler versions upload` output.");
 	return {
 		versionId,
 		previewUrl,
+		workerName,
 		output
 	};
 }
@@ -81,6 +105,21 @@ function buildWranglerVersionUploadArgs(options) {
 		env
 	};
 }
+function buildCfVersionUploadArgs(options) {
+	const mode = options.env || (options.preview ? "preview" : void 0);
+	const args = [
+		"workers",
+		"versions",
+		"create",
+		"--prebuilt"
+	];
+	if (mode) args.push("--mode", validateWranglerEnvName(mode));
+	if (options.previewAlias) args.push("--preview-alias", options.previewAlias);
+	return {
+		args,
+		mode
+	};
+}
 function buildWranglerVersionDeployArgs(versionTraffic, options) {
 	const args = [
 		"versions",
@@ -123,8 +162,9 @@ function buildWranglerTriggersDeployArgs(options) {
 		env
 	};
 }
-function runWranglerCommand(root, args, execute = execFileSync) {
-	const invocation = buildNodeCliInvocation(resolveWranglerBin(root), args);
+function runWranglerCommand(root, args, execute = execFileSync, verbose = false) {
+	const wranglerBin = resolveWranglerBin(root);
+	const invocation = buildNodeCliInvocation(wranglerBin, args);
 	const execOpts = {
 		cwd: root,
 		stdio: "pipe",
@@ -132,7 +172,18 @@ function runWranglerCommand(root, args, execute = execFileSync) {
 		shell: false
 	};
 	const output = execute(invocation.file, invocation.args, execOpts);
-	if (output.trim()) for (const line of output.trim().split("\n")) console.log(`  ${line}`);
+	if (verbose && output.trim()) for (const line of output.trim().split("\n")) console.log(`  ${line}`);
+	return output;
+}
+function runCfCommand(root, args, execute = execFileSync, verbose = false) {
+	const invocation = buildNodeCliInvocation(resolveCfBin(root), args);
+	const output = execute(invocation.file, invocation.args, {
+		cwd: root,
+		stdio: "pipe",
+		encoding: "utf-8",
+		shell: false
+	});
+	if (verbose && output.trim()) for (const line of output.trim().split("\n")) console.log(`  ${line}`);
 	return output;
 }
 function errorText(error) {
@@ -154,7 +205,7 @@ function isMissingWorkerVersionUploadError(error) {
 	return /cannot upload a new version of a Worker that does not yet exist/i.test(errorText(error));
 }
 function withInitialDeployRequiredMessage() {
-	return /* @__PURE__ */ new Error("CDN pre-warm needs an existing Cloudflare Worker before it can upload a new Worker version. Run `vinext-cloudflare deploy` once without `--experimental-warm-cdn-cache` to create the Worker, then rerun your pre-warm deploy.");
+	return /* @__PURE__ */ new Error("Version upload needs an existing Cloudflare Worker. Run `vinext-cloudflare deploy` once normally to create the Worker, then rerun the version-based deploy.");
 }
 function parseDeploymentVersions(value) {
 	const deployment = Array.isArray(value) ? value.at(-1) : value;
@@ -176,16 +227,100 @@ function parseWranglerDeploymentStatusOutput(output) {
 	const parsed = parseJsonObject(output);
 	if (!parsed) throw new Error("Could not parse `wrangler deployments status --json` output.");
 	return {
+		deploymentId: findStringInRecord(Array.isArray(parsed) ? parsed.at(-1) : parsed, [
+			"id",
+			"deployment_id",
+			"deploymentId"
+		]),
 		versions: parseDeploymentVersions(parsed),
 		output
 	};
 }
+/** The first entry is the deployment currently serving traffic. */
+function parseCfDeploymentStatusOutput(output) {
+	const parsed = parseJsonObject(output);
+	if (!isRecord(parsed) || !Array.isArray(parsed.deployments) || !parsed.deployments.length) throw new Error("Could not parse the active deployment from `cf workers deployments list` output.");
+	const current = parsed.deployments[0];
+	const deploymentId = findStringInRecord(current, [
+		"id",
+		"deployment_id",
+		"deploymentId"
+	]);
+	const versions = parseDeploymentVersions(current);
+	if (!deploymentId || !versions.length) throw new Error("The active `cf workers deployments list` entry is missing its ID or versions.");
+	return {
+		deploymentId,
+		versions,
+		output
+	};
+}
+function runCfDeploymentStatus(root, options, execute = execFileSync) {
+	return parseCfDeploymentStatusOutput(runCfCommand(root, [
+		"workers",
+		"deployments",
+		"list",
+		"--worker",
+		options.name,
+		...options.env ? ["--mode", validateWranglerEnvName(options.env)] : []
+	], execute, options.verbose));
+}
+function runCfVersionDeploy(root, versionTraffic, options, _phase = "promote-uploaded", execute = execFileSync) {
+	const versions = versionTraffic.map(({ versionId, percentage }) => ({
+		version_id: versionId,
+		percentage
+	}));
+	const output = runCfCommand(root, [
+		"workers",
+		"deployments",
+		"create",
+		"--worker",
+		options.name,
+		"--strategy",
+		"percentage",
+		"--versions",
+		JSON.stringify(versions),
+		...options.env ? ["--mode", validateWranglerEnvName(options.env)] : []
+	], execute, options.verbose);
+	return {
+		deployedUrl: parseWorkersDevUrl(output),
+		output
+	};
+}
+function runCfTriggersDeploy(root, options, execute = execFileSync) {
+	const output = runCfCommand(root, [
+		"workers",
+		"triggers",
+		"deploy",
+		"--prebuilt",
+		...options.env ? ["--mode", validateWranglerEnvName(options.env)] : []
+	], execute, options.verbose);
+	return {
+		deployedUrl: parseCdnWarmupDeploymentUrl(output),
+		output
+	};
+}
 function runWranglerVersionUpload(root, options, execute = execFileSync) {
 	const { args, env } = buildWranglerVersionUploadArgs(options);
 	if (env) console.log(`\n  Uploading Worker version for env: ${env}...`);
 	else console.log("\n  Uploading Worker version for production...");
 	try {
-		return parseWranglerVersionUploadOutput(runWranglerCommand(root, args, execute));
+		const upload = parseWranglerVersionUploadOutput(runWranglerCommand(root, args, execute, options.verbose === true));
+		console.log(`  Worker version ID: ${upload.versionId}`);
+		return upload;
+	} catch (error) {
+		if (isMissingWorkerVersionUploadError(error)) throw withInitialDeployRequiredMessage();
+		throw error;
+	}
+}
+function runCfVersionUpload(root, options, execute = execFileSync) {
+	const workerName = readBuildOutputWorkerName(root);
+	const { args, mode } = buildCfVersionUploadArgs(options);
+	console.log(mode ? `\n  Uploading Worker Build Output in mode: ${mode}...` : "\n  Uploading Worker Build Output...");
+	try {
+		return {
+			...parseWranglerVersionUploadOutput(runCfCommand(root, args, execute, options.verbose === true)),
+			workerName
+		};
 	} catch (error) {
 		if (isMissingWorkerVersionUploadError(error)) throw withInitialDeployRequiredMessage();
 		throw error;
@@ -197,7 +332,7 @@ function runWranglerVersionDeploy(root, versionTraffic, options, phase = "promot
 	if (phase === "stage") console.log(`\n  Staging uploaded Worker version at 0% for CDN warmup in ${target}...`);
 	else if (phase === "promote-warmed") console.log(`\n  Promoting warmed Worker version to ${target}...`);
 	else console.log(`\n  Promoting uploaded Worker version to ${target}...`);
-	const output = runWranglerCommand(root, args, execute);
+	const output = runWranglerCommand(root, args, execute, options.verbose === true);
 	return {
 		deployedUrl: parseWorkersDevUrl(output),
 		output
@@ -205,19 +340,21 @@ function runWranglerVersionDeploy(root, versionTraffic, options, phase = "promot
 }
 function runWranglerDeploymentStatus(root, options, execute = execFileSync) {
 	const { args, env } = buildWranglerDeploymentsStatusArgs(options);
-	if (env) console.log(`\n  Reading current Worker deployment for env: ${env}...`);
-	else console.log("\n  Reading current Worker deployment...");
-	return parseWranglerDeploymentStatusOutput(runWranglerCommand(root, args, execute));
+	if (options.verbose) {
+		if (env) console.log(`\n  Reading current Worker deployment for env: ${env}...`);
+		else console.log("\n  Reading current Worker deployment...");
+	}
+	return parseWranglerDeploymentStatusOutput(runWranglerCommand(root, args, execute, options.verbose === true));
 }
 function runWranglerTriggersDeploy(root, options, execute = execFileSync) {
 	const { args, env } = buildWranglerTriggersDeployArgs(options);
 	if (env) console.log(`\n  Applying Worker triggers for env: ${env}...`);
 	else console.log("\n  Applying Worker triggers...");
-	const output = runWranglerCommand(root, args, execute);
+	const output = runWranglerCommand(root, args, execute, options.verbose === true);
 	return {
-		deployedUrl: parseWorkersDevUrl(output),
+		deployedUrl: parseCdnWarmupDeploymentUrl(output),
 		output
 	};
 }
 //#endregion
-export { buildWranglerDeploymentsStatusArgs, buildWranglerTriggersDeployArgs, buildWranglerVersionDeployArgs, buildWranglerVersionUploadArgs, parseVersionId, parseWorkersDevUrl, parseWranglerDeploymentStatusOutput, parseWranglerVersionUploadOutput, runWranglerDeploymentStatus, runWranglerTriggersDeploy, runWranglerVersionDeploy, runWranglerVersionUpload };
+export { buildCfVersionUploadArgs, buildWranglerDeploymentsStatusArgs, buildWranglerTriggersDeployArgs, buildWranglerVersionDeployArgs, buildWranglerVersionUploadArgs, parseCfDeploymentStatusOutput, parseUploadedWorkerName, parseVersionId, parseWorkersDevUrl, parseWranglerDeploymentStatusOutput, parseWranglerVersionUploadOutput, readBuildOutputWorkerName, runCfDeploymentStatus, runCfTriggersDeploy, runCfVersionDeploy, runCfVersionUpload, runWranglerDeploymentStatus, runWranglerTriggersDeploy, runWranglerVersionDeploy, runWranglerVersionUpload };

package/dist/version-headers.d.ts

@@ -0,0 +1,2 @@
+import { VINEXT_EXPECTED_WORKER_VERSION_HEADER } from "vinext/internal/server/headers";
+export { VINEXT_EXPECTED_WORKER_VERSION_HEADER };

package/dist/version-headers.js

@@ -0,0 +1,2 @@
+import { VINEXT_EXPECTED_WORKER_VERSION_HEADER } from "vinext/internal/server/headers";
+export { VINEXT_EXPECTED_WORKER_VERSION_HEADER };

package/dist/worker-deployment-url.d.ts

@@ -0,0 +1,9 @@
+//#region src/worker-deployment-url.d.ts
+export declare function parseWorkerDeploymentUrl(output: string): string | null;
+/**
+ * Parse the concrete hostname that Wrangler reports after applying Worker
+ * triggers. Catch-all routes are valid warmup targets even though they are not
+ * canonical deployment URLs for general CLI reporting.
+ */
+export declare function parseCdnWarmupDeploymentUrl(output: string): string | null;
+//#endregion

package/dist/worker-deployment-url.js

@@ -0,0 +1,45 @@
+import { parseWorkersDevUrl } from "./workers-dev-url.js";
+//#region src/worker-deployment-url.ts
+function parseWorkerDeploymentUrl(output) {
+	return parseWorkersDevUrl(output) ?? parseCustomDomainUrl(output);
+}
+/**
+* Parse the concrete hostname that Wrangler reports after applying Worker
+* triggers. Catch-all routes are valid warmup targets even though they are not
+* canonical deployment URLs for general CLI reporting.
+*/
+function parseCdnWarmupDeploymentUrl(output) {
+	return parseCustomDomainUrl(output) ?? parseCatchAllWorkerRouteOrigin(output) ?? parseWorkersDevUrl(output);
+}
+function parseCatchAllWorkerRouteOrigin(output) {
+	for (const line of output.split(/\r?\n/)) {
+		const route = line.trim().split(/\s+/, 1)[0];
+		if (!route || !route.endsWith("/*")) continue;
+		try {
+			const url = new URL(route.includes("://") ? route : `https://${route}`);
+			if (url.protocol !== "https:" && url.protocol !== "http:" || url.hostname.includes("*") || url.username !== "" || url.password !== "" || url.port !== "" || url.pathname !== "/*" || url.search !== "" || url.hash !== "") continue;
+			return url.origin;
+		} catch {
+			continue;
+		}
+	}
+	return null;
+}
+function parseCustomDomainUrl(output) {
+	for (const line of output.split(/\r?\n/)) {
+		const match = /^\s*(\S+)\s+\(custom domain(?: - zone (?:id|name): [^)]+)?\)(?: \[([^\]\r\n]+)\])?\s*$/.exec(line);
+		const hostname = match?.[1];
+		if (!hostname) continue;
+		if (match[2]?.split(",").some((flag) => flag.trim() === "disabled")) continue;
+		try {
+			const url = new URL(`https://${hostname}`);
+			if (url.username !== "" || url.password !== "" || url.port !== "" || url.pathname !== "/" || url.search !== "" || url.hash !== "") continue;
+			return url.origin;
+		} catch {
+			continue;
+		}
+	}
+	return null;
+}
+//#endregion
+export { parseCdnWarmupDeploymentUrl, parseWorkerDeploymentUrl };

package/dist/workers-dev-url.d.ts

@@ -1,4 +1,3 @@
 //#region src/workers-dev-url.d.ts
-declare function parseWorkersDevUrl(output: string): string | null;
-//#endregion
-export { parseWorkersDevUrl };
+export declare function parseWorkersDevUrl(output: string): string | null;
+//#endregion

package/dist/wrangler-config.d.ts

@@ -0,0 +1,19 @@
+//#region src/wrangler-config.d.ts
+/** Narrow Wrangler config projection shared by deploy-time features. */
+type WranglerConfig = {
+  accountId?: string;
+  kvNamespaceId?: string;
+  customDomain?: string;
+  name?: string;
+  legacyEnv?: boolean;
+  env?: Record<string, WranglerEnvironmentConfig>;
+};
+type WranglerEnvironmentConfig = {
+  customDomain?: string;
+  name?: string;
+};
+/**
+ * Parse the Wrangler fields used by TPR and staged CDN warming.
+ */
+export declare function parseWranglerConfig(root: string, configPath?: string): WranglerConfig | null;
+//#endregion