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

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,21 @@ 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"> & {
+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 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;
+export declare function runWranglerVersionUpload(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,4 +1,5 @@
 import { parseWorkersDevUrl } from "./workers-dev-url.js";
+import { parseCdnWarmupDeploymentUrl } from "./worker-deployment-url.js";
 import { buildNodeCliInvocation, resolveWranglerBin, validateWranglerEnvName } from "./deploy.js";
 import { execFileSync } from "node:child_process";
 //#region src/version-deploy.ts
@@ -56,16 +57,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 output.match(/^\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
 	};
 }
@@ -123,8 +132,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 +142,7 @@ 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 errorText(error) {
@@ -154,7 +164,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,6 +186,11 @@ 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
 	};
@@ -185,7 +200,9 @@ function runWranglerVersionUpload(root, options, execute = execFileSync) {
 	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;
@@ -197,7 +214,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 +222,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 { buildWranglerDeploymentsStatusArgs, buildWranglerTriggersDeployArgs, buildWranglerVersionDeployArgs, buildWranglerVersionUploadArgs, parseUploadedWorkerName, parseVersionId, parseWorkersDevUrl, parseWranglerDeploymentStatusOutput, parseWranglerVersionUploadOutput, 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

package/dist/wrangler-config.js

@@ -0,0 +1,294 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/wrangler-config.ts
+/** Narrow Wrangler config projection shared by deploy-time features. */
+/**
+* Parse the Wrangler fields used by TPR and staged CDN warming.
+*/
+function parseWranglerConfig(root, configPath) {
+	if (configPath) {
+		const filepath = path.resolve(root, configPath);
+		if (!fs.existsSync(filepath)) return null;
+		const content = fs.readFileSync(filepath, "utf-8");
+		if (filepath.endsWith(".toml")) return extractFromTOML(content);
+		try {
+			return extractFromJSON(JSON.parse(stripJsonCommentsAndTrailingCommas(content)));
+		} catch {
+			return null;
+		}
+	}
+	for (const filename of ["wrangler.jsonc", "wrangler.json"]) {
+		const filepath = path.join(root, filename);
+		if (fs.existsSync(filepath)) {
+			const content = fs.readFileSync(filepath, "utf-8");
+			try {
+				return extractFromJSON(JSON.parse(stripJsonCommentsAndTrailingCommas(content)));
+			} catch {
+				continue;
+			}
+		}
+	}
+	const tomlPath = path.join(root, "wrangler.toml");
+	if (fs.existsSync(tomlPath)) return extractFromTOML(fs.readFileSync(tomlPath, "utf-8"));
+	return null;
+}
+/**
+* Strip single-line (//), multi-line comments, and trailing commas from JSONC
+* while preserving strings that contain comment-like text or commas.
+*/
+function stripJsonCommentsAndTrailingCommas(str) {
+	let result = "";
+	let inString = false;
+	let inSingleLine = false;
+	let inMultiLine = false;
+	let escapeNext = false;
+	for (let i = 0; i < str.length; i++) {
+		const ch = str[i];
+		const next = str[i + 1];
+		if (escapeNext) {
+			if (!inSingleLine && !inMultiLine) result += ch;
+			escapeNext = false;
+			continue;
+		}
+		if (ch === "\\" && inString) {
+			result += ch;
+			escapeNext = true;
+			continue;
+		}
+		if (inSingleLine) {
+			if (ch === "\n") {
+				inSingleLine = false;
+				result += ch;
+			}
+			continue;
+		}
+		if (inMultiLine) {
+			if (ch === "*" && next === "/") {
+				inMultiLine = false;
+				i++;
+			}
+			continue;
+		}
+		if (ch === "\"" && !inString) {
+			inString = true;
+			result += ch;
+			continue;
+		}
+		if (ch === "\"" && inString) {
+			inString = false;
+			result += ch;
+			continue;
+		}
+		if (!inString && ch === "/" && next === "/") {
+			inSingleLine = true;
+			i++;
+			continue;
+		}
+		if (!inString && ch === "/" && next === "*") {
+			inMultiLine = true;
+			i++;
+			continue;
+		}
+		if (!inString && ch === "," && isJsonTrailingComma(str, i + 1)) continue;
+		result += ch;
+	}
+	return result;
+}
+function isJsonTrailingComma(str, start) {
+	for (let i = start; i < str.length; i++) {
+		const ch = str[i];
+		const next = str[i + 1];
+		if (ch === void 0) return false;
+		if (/\s/.test(ch)) continue;
+		if (ch === "/" && next === "/") {
+			i += 2;
+			while (i < str.length && str[i] !== "\n") i++;
+			continue;
+		}
+		if (ch === "/" && next === "*") {
+			i += 2;
+			while (i < str.length) {
+				if (str[i] === "*" && str[i + 1] === "/") {
+					i++;
+					break;
+				}
+				i++;
+			}
+			continue;
+		}
+		return ch === "}" || ch === "]";
+	}
+	return false;
+}
+function extractFromJSON(config) {
+	const result = {};
+	if (typeof config.name === "string" && config.name.length > 0) result.name = config.name;
+	if (typeof config.legacy_env === "boolean") result.legacyEnv = config.legacy_env;
+	if (typeof config.account_id === "string") result.accountId = config.account_id;
+	if (Array.isArray(config.kv_namespaces)) {
+		const namespace = config.kv_namespaces.find((value) => value && typeof value === "object" && (value.binding === "VINEXT_KV_CACHE" || value.binding === "VINEXT_CACHE"));
+		if (namespace && typeof namespace.id === "string" && namespace.id !== "<your-kv-namespace-id>") result.kvNamespaceId = namespace.id;
+	}
+	const domain = extractDomainFromRoutes(config.routes) ?? extractDomainFromCustomDomains(config);
+	if (domain) result.customDomain = domain;
+	const env = extractEnvConfigs(config.env);
+	if (env) result.env = env;
+	return result;
+}
+function extractEnvConfigs(envs) {
+	if (!envs || typeof envs !== "object" || Array.isArray(envs)) return void 0;
+	const result = {};
+	for (const [envName, rawConfig] of Object.entries(envs)) {
+		if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) continue;
+		const envConfig = extractEnvironmentConfig(rawConfig);
+		if (envConfig.name || envConfig.customDomain) result[envName] = envConfig;
+	}
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function extractEnvironmentConfig(config) {
+	const result = {};
+	if (typeof config.name === "string" && config.name.length > 0) result.name = config.name;
+	const domain = extractDomainFromRoutes(config.routes) ?? extractDomainFromCustomDomains(config);
+	if (domain) result.customDomain = domain;
+	return result;
+}
+function extractDomainFromRoutes(routes) {
+	if (!Array.isArray(routes)) return null;
+	for (const route of routes) if (typeof route === "string") {
+		const domain = cleanDomain(route);
+		if (domain && !domain.includes("workers.dev")) return domain;
+	} else if (route && typeof route === "object") {
+		const r = route;
+		const pattern = typeof r.zone_name === "string" ? r.zone_name : typeof r.pattern === "string" ? r.pattern : null;
+		if (pattern) {
+			const domain = cleanDomain(pattern);
+			if (domain && !domain.includes("workers.dev")) return domain;
+		}
+	}
+	return null;
+}
+function extractDomainFromCustomDomains(config) {
+	if (Array.isArray(config.custom_domains)) {
+		for (const d of config.custom_domains) if (typeof d === "string" && !d.includes("workers.dev")) return cleanDomain(d);
+	}
+	return null;
+}
+/** Strip protocol and trailing wildcards from a route pattern to get a bare domain. */
+function cleanDomain(raw) {
+	return raw.replace(/^https?:\/\//, "").replace(/\/\*$/, "").replace(/\/+$/, "").split("/")[0] || null;
+}
+/**
+* Simple extraction of specific fields from wrangler.toml content.
+* Not a full TOML parser — just enough for the fields we need.
+*/
+function extractFromTOML(content) {
+	const result = {};
+	const nameMatch = content.match(/^name\s*=\s*"([^"]+)"/m);
+	if (nameMatch) result.name = nameMatch[1];
+	const legacyEnvMatch = content.match(/^legacy_env\s*=\s*(true|false)\s*$/m);
+	if (legacyEnvMatch) result.legacyEnv = legacyEnvMatch[1] === "true";
+	const accountMatch = content.match(/^account_id\s*=\s*"([^"]+)"/m);
+	if (accountMatch) result.accountId = accountMatch[1];
+	for (const block of content.split(/\[\[kv_namespaces\]\]/).slice(1)) {
+		const section = block.split(/\[\[/)[0];
+		const binding = section.match(/binding\s*=\s*"([^"]+)"/)?.[1];
+		const id = section.match(/\bid\s*=\s*"([^"]+)"/)?.[1];
+		if ((binding === "VINEXT_KV_CACHE" || binding === "VINEXT_CACHE") && id && id !== "<your-kv-namespace-id>") result.kvNamespaceId = id;
+	}
+	const routeMatch = content.match(/^route\s*=\s*"([^"]+)"/m);
+	if (routeMatch) {
+		const domain = cleanDomain(routeMatch[1]);
+		if (domain && !domain.includes("workers.dev")) result.customDomain = domain;
+	}
+	if (!result.customDomain) {
+		const routeBlocks = content.split(/\[\[routes\]\]/);
+		for (let i = 1; i < routeBlocks.length; i++) {
+			const patternMatch = routeBlocks[i].split(/\[\[/)[0].match(/pattern\s*=\s*"([^"]+)"/);
+			if (patternMatch) {
+				const domain = cleanDomain(patternMatch[1]);
+				if (domain && !domain.includes("workers.dev")) {
+					result.customDomain = domain;
+					break;
+				}
+			}
+		}
+	}
+	const env = extractEnvConfigsFromTOML(content);
+	if (env) result.env = env;
+	return result;
+}
+function extractEnvConfigsFromTOML(content) {
+	const result = {};
+	for (const section of getTomlSections(content)) {
+		const envName = section.header.match(/^env\.([^.]+)$/)?.[1];
+		if (envName) {
+			const envConfig = result[envName] ?? {};
+			const nameMatch = section.body.match(/^name\s*=\s*"([^"]+)"/m);
+			if (nameMatch) envConfig.name = nameMatch[1];
+			const domain = extractTomlScalarRouteDomain(section.body) ?? extractTomlRoutesArrayDomain(section.body);
+			if (domain) envConfig.customDomain = domain;
+			if (envConfig.name || envConfig.customDomain) result[envName] = envConfig;
+			continue;
+		}
+		const routesEnvName = section.header.match(/^env\.([^.]+)\.routes$/)?.[1];
+		if (routesEnvName) {
+			const envConfig = result[routesEnvName] ?? {};
+			const domain = extractTomlRouteBlockDomain(section.body);
+			if (domain) envConfig.customDomain = domain;
+			if (envConfig.name || envConfig.customDomain) result[routesEnvName] = envConfig;
+		}
+	}
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function getTomlSections(content) {
+	const sections = [];
+	let currentHeader = null;
+	let currentBody = [];
+	for (const line of content.split("\n")) {
+		const header = parseTomlSectionHeader(line);
+		if (header) {
+			if (currentHeader) sections.push({
+				header: currentHeader,
+				body: currentBody.join("\n")
+			});
+			currentHeader = header;
+			currentBody = [];
+		} else if (currentHeader) currentBody.push(line);
+	}
+	if (currentHeader) sections.push({
+		header: currentHeader,
+		body: currentBody.join("\n")
+	});
+	return sections;
+}
+function parseTomlSectionHeader(line) {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return null;
+	const isArrayHeader = trimmed.startsWith("[[") && trimmed.endsWith("]]");
+	const start = isArrayHeader ? 2 : 1;
+	const end = isArrayHeader ? trimmed.length - 2 : trimmed.length - 1;
+	const header = trimmed.slice(start, end).trim();
+	return header.length > 0 ? header : null;
+}
+function extractTomlScalarRouteDomain(section) {
+	const routeMatch = section.match(/^route\s*=\s*"([^"]+)"/m);
+	if (!routeMatch) return null;
+	const domain = cleanDomain(routeMatch[1]);
+	return domain && !domain.includes("workers.dev") ? domain : null;
+}
+function extractTomlRoutesArrayDomain(section) {
+	const routesMatch = section.match(/^routes\s*=\s*\[([\s\S]*?)\]/m);
+	if (!routesMatch) return null;
+	const patternMatch = (routesMatch[1] ?? "").match(/(?:pattern\s*=\s*)?"([^"]+)"/);
+	if (!patternMatch) return null;
+	const domain = cleanDomain(patternMatch[1]);
+	return domain && !domain.includes("workers.dev") ? domain : null;
+}
+function extractTomlRouteBlockDomain(section) {
+	const patternMatch = section.match(/^pattern\s*=\s*"([^"]+)"/m) ?? section.match(/^zone_name\s*=\s*"([^"]+)"/m);
+	if (!patternMatch) return null;
+	const domain = cleanDomain(patternMatch[1]);
+	return domain && !domain.includes("workers.dev") ? domain : null;
+}
+//#endregion
+export { parseWranglerConfig };

package/dist/wrangler-version-metadata.d.ts

@@ -0,0 +1,7 @@
+//#region src/wrangler-version-metadata.d.ts
+export declare function assertCdnVersionMetadataConfig({ binding, configuredBinding, configPath }: {
+  binding: string;
+  configuredBinding: string | undefined;
+  configPath: string | undefined;
+}): void;
+//#endregion

package/dist/wrangler-version-metadata.js

@@ -0,0 +1,9 @@
+//#region src/wrangler-version-metadata.ts
+function assertCdnVersionMetadataConfig({ binding, configuredBinding, configPath }) {
+	if (configuredBinding === binding) return;
+	const location = configPath ? ` in ${configPath}` : "";
+	const found = configuredBinding ? ` declares ${JSON.stringify(configuredBinding)} instead` : " does not declare version_metadata";
+	throw new Error(`[vinext] Cloudflare CDN warmup requires version metadata binding ${JSON.stringify(binding)}, but the effective Wrangler config${location}${found}. Deploy the generated Wrangler config finalized by cdnAdapter(), or add the binding to this effective config and align cdnAdapter({ versionMetadataBinding }) when using a custom name.`);
+}
+//#endregion
+export { assertCdnVersionMetadataConfig };

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@vinext/cloudflare",
-  "version": "1.0.0-beta.1",
-  "description": "Cloudflare adapters for vinext (KV data cache and Images-backed image optimization).",
+  "version": "1.0.0-beta.10",
+  "description": "Cloudflare cache and image adapters for vinext.",
+  "homepage": "https://vinext.dev/",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -29,10 +30,6 @@
       "types": "./dist/deploy-config.d.ts",
       "import": "./dist/deploy-config.js"
     },
-    "./internal/tpr": {
-      "types": "./dist/tpr.d.ts",
-      "import": "./dist/tpr.js"
-    },
     "./internal/cdn-warm": {
       "types": "./dist/cdn-warm.d.ts",
       "import": "./dist/cdn-warm.js"
@@ -50,20 +47,26 @@
       "import": "./dist/images/*.js"
     }
   },
+  "dependencies": {
+    "@cloudflare/workers-response-store": "0.1.0-beta.2"
+  },
   "devDependencies": {
     "@types/node": "^25.9.2",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.2",
-    "vite-plus": "0.2.2",
-    "vinext": "1.0.0-beta.1"
+    "miniflare": "5.20260730.0-alpha",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.3.2",
+    "vite-plus": "0.3.2",
+    "vitest": "4.1.11",
+    "vinext": "1.0.0-beta.12"
   },
   "peerDependencies": {
-    "vinext": ">=0.0.0"
+    "vinext": "^1.0.0-beta.12"
   },
   "engines": {
     "node": ">=22"
   },
   "scripts": {
     "build": "vp pack",
-    "dev": "vp pack --watch"
+    "dev": "vp pack --watch",
+    "test": "vp run vinext#build && vp run @cloudflare/workers-response-store#build && vp run @vinext/cloudflare#build && VINEXT_RESPONSE_STORE_MODE=self-contained VINEXT_RESPONSE_STORE_LOCATION_HINT=weur pnpm --filter response-store-demo run build && VINEXT_RESPONSE_STORE_LOCATION_HINT=wnam pnpm --filter response-store-demo run build && vitest run"
   }
 }