@vinext/cloudflare 0.2.0 → 1.0.0-beta.0

package/dist/tpr.js

@@ -1,7 +1,7 @@
 import { ENTRY_PREFIX } from "./cache/kv-data-adapter.runtime.js";
 import { createRequire } from "node:module";
-import fs from "node:fs";
 import path from "node:path";
+import fs from "node:fs";
 import { spawn } from "node:child_process";
 import { pathToFileURL } from "node:url";
 import { VINEXT_REVALIDATE_HEADER } from "vinext/internal/server/headers";
@@ -33,13 +33,24 @@ import { buildAppPageCacheTags } from "vinext/internal/server/app-page-cache";
 * Parse wrangler config (JSONC or TOML) to extract the fields TPR needs:
 * account_id, VINEXT_KV_CACHE KV namespace ID, and custom domain.
 */
-function parseWranglerConfig(root) {
+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(stripJsonComments(content)));
+				return extractFromJSON(JSON.parse(stripJsonCommentsAndTrailingCommas(content)));
 			} catch {
 				continue;
 			}
@@ -50,10 +61,10 @@ function parseWranglerConfig(root) {
 	return null;
 }
 /**
-* Strip single-line (//) and multi-line comments from JSONC while
-* preserving strings that contain slashes.
+* Strip single-line (//), multi-line comments, and trailing commas from JSONC
+* while preserving strings that contain comment-like text or commas.
 */
-function stripJsonComments(str) {
+function stripJsonCommentsAndTrailingCommas(str) {
 	let result = "";
 	let inString = false;
 	let inSingleLine = false;
@@ -106,12 +117,41 @@ function stripJsonComments(str) {
 			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 vinextKV = config.kv_namespaces.find((ns) => ns && typeof ns === "object" && (ns.binding === "VINEXT_KV_CACHE" || ns.binding === "VINEXT_CACHE"));
@@ -119,6 +159,25 @@ function extractFromJSON(config) {
 	}
 	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) {
@@ -152,6 +211,10 @@ function cleanDomain(raw) {
 */
 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];
 	const kvBlocks = content.split(/\[\[kv_namespaces\]\]/);
@@ -179,8 +242,83 @@ function extractFromTOML(content) {
 			}
 		}
 	}
+	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|zone_name)\s*=\s*"([^"]+)"/m);
+	if (!patternMatch) return null;
+	const domain = cleanDomain(patternMatch[1]);
+	return domain && !domain.includes("workers.dev") ? domain : null;
+}
 /**
 * Generate zone lookup candidates from shortest (2-part) to longest.
 * Tries the most common case first (e.g., "example.com") and progressively
@@ -306,6 +444,25 @@ const PRERENDER_PORT = 19384;
 const SERVER_STARTUP_TIMEOUT = 3e4;
 /** Max concurrent fetch requests during pre-rendering. */
 const FETCH_CONCURRENCY = 10;
+const NON_CACHEABLE_CACHE_CONTROL_RE = /\b(?:no-store|no-cache|private)\b/i;
+function getTprHeader(headers, name) {
+	const normalizedName = name.toLowerCase();
+	for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === normalizedName) return value;
+}
+function hasNonCacheableCacheControl(headers) {
+	const cacheControl = getTprHeader(headers, "cache-control");
+	return cacheControl ? NON_CACHEABLE_CACHE_CONTROL_RE.test(cacheControl) : false;
+}
+function readTprRevalidateHeader(headers) {
+	const revalidateHeader = getTprHeader(headers, VINEXT_REVALIDATE_HEADER);
+	if (revalidateHeader === void 0) return void 0;
+	return Number(revalidateHeader);
+}
+function isTprCacheable(headers) {
+	if (hasNonCacheableCacheControl(headers)) return false;
+	const revalidate = readTprRevalidateHeader(headers);
+	return revalidate === void 0 || Number.isFinite(revalidate) && revalidate > 0;
+}
 /**
 * Start a local production server, fetch each route to produce HTML,
 * and return the results. Pages that fail to render are skipped.
@@ -333,11 +490,12 @@ async function prerenderRoutes(routes, root, hostDomain) {
 						redirect: "manual"
 					});
 					if (response.status < 400) {
-						const html = await response.text();
 						const headers = {};
 						response.headers.forEach((value, key) => {
 							if (key === "content-type" || key === "cache-control" || key === VINEXT_REVALIDATE_HEADER || key === "location") headers[key] = value;
 						});
+						if (!isTprCacheable(headers)) return;
+						const html = await response.text();
 						results.set(routePath, {
 							html,
 							status: response.status,
@@ -427,10 +585,11 @@ function buildTprKVPairs(entries, buildId, defaultRevalidateSeconds) {
 	const now = Date.now();
 	const pairs = [];
 	for (const [routePath, result] of entries) {
-		const revalidateHeader = result.headers[VINEXT_REVALIDATE_HEADER];
-		const revalidateSeconds = revalidateHeader && !isNaN(Number(revalidateHeader)) ? Number(revalidateHeader) : defaultRevalidateSeconds;
-		const revalidateAt = revalidateSeconds > 0 ? now + revalidateSeconds * 1e3 : null;
-		const kvTtl = revalidateSeconds > 0 ? MAX_KV_TTL_SECONDS : 24 * 3600;
+		if (!isTprCacheable(result.headers)) continue;
+		const revalidateSeconds = readTprRevalidateHeader(result.headers) ?? defaultRevalidateSeconds;
+		if (!Number.isFinite(revalidateSeconds) || revalidateSeconds <= 0) continue;
+		const revalidateAt = now + revalidateSeconds * 1e3;
+		const kvTtl = MAX_KV_TTL_SECONDS;
 		const tags = buildAppPageCacheTags(routePath, []);
 		const entry = {
 			value: {
@@ -486,7 +645,7 @@ const DEFAULT_REVALIDATE_SECONDS = 3600;
 */
 async function runTPR(options) {
 	const startTime = Date.now();
-	const { root, coverage, limit, window: windowHours } = options;
+	const { root, config, coverage, limit, window: windowHours } = options;
 	const skip = (reason) => ({
 		totalPaths: 0,
 		prerenderedCount: 0,
@@ -496,7 +655,7 @@ async function runTPR(options) {
 	});
 	const apiToken = process.env.CLOUDFLARE_API_TOKEN;
 	if (!apiToken) return skip("no CLOUDFLARE_API_TOKEN set");
-	const wranglerConfig = parseWranglerConfig(root);
+	const wranglerConfig = parseWranglerConfig(root, config);
 	if (!wranglerConfig) return skip("could not parse wrangler config");
 	if (!wranglerConfig.customDomain) return skip("no custom domain — zone analytics unavailable");
 	if (!wranglerConfig.kvNamespaceId) return skip("no VINEXT_KV_CACHE KV namespace configured");

package/dist/version-deploy.d.ts

@@ -0,0 +1,43 @@
+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 = {
+  versionId: string;
+  previewUrl: string | null;
+  output: string;
+};
+type WranglerVersionDeployResult = {
+  deployedUrl: string | null;
+  output: string;
+};
+type WranglerVersionTraffic = {
+  versionId: string;
+  percentage: number;
+};
+type WranglerDeploymentStatus = {
+  versions: WranglerVersionTraffic[];
+  output: string;
+};
+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"> & {
+  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"> & {
+  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;
+//#endregion
+export { WranglerDeploymentStatus, WranglerVersionDeployResult, WranglerVersionTraffic, WranglerVersionUploadResult, buildWranglerDeploymentsStatusArgs, buildWranglerTriggersDeployArgs, buildWranglerVersionDeployArgs, buildWranglerVersionUploadArgs, parseVersionId, parseWorkersDevUrl, parseWranglerDeploymentStatusOutput, parseWranglerVersionUploadOutput, runWranglerDeploymentStatus, runWranglerTriggersDeploy, runWranglerVersionDeploy, runWranglerVersionUpload };

package/dist/version-deploy.js

@@ -0,0 +1,223 @@
+import { parseWorkersDevUrl } from "./workers-dev-url.js";
+import { buildNodeCliInvocation, resolveWranglerBin, validateWranglerEnvName } from "./deploy.js";
+import { execFileSync } from "node:child_process";
+//#region src/version-deploy.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonObject(output) {
+	const trimmed = output.trim();
+	if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return null;
+	try {
+		const parsed = JSON.parse(trimmed);
+		return isRecord(parsed) || Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function findStringInRecord(value, keys) {
+	if (!isRecord(value)) return null;
+	for (const key of keys) {
+		const field = value[key];
+		if (typeof field === "string" && field.length > 0) return field;
+	}
+	return null;
+}
+function findVersionIdInUploadJson(parsed) {
+	if (!isRecord(parsed)) return null;
+	return findStringInRecord(parsed, [
+		"version_id",
+		"versionId",
+		"id"
+	]) ?? findStringInRecord(parsed.version, [
+		"version_id",
+		"versionId",
+		"id"
+	]) ?? findStringInRecord(parsed.result, [
+		"version_id",
+		"versionId",
+		"id"
+	]);
+}
+function findPreviewUrlInUploadJson(parsed) {
+	if (!isRecord(parsed)) return null;
+	return findStringInRecord(parsed, [
+		"preview_url",
+		"previewUrl",
+		"url"
+	]) ?? findStringInRecord(parsed.version, [
+		"preview_url",
+		"previewUrl",
+		"url"
+	]) ?? findStringInRecord(parsed.result, [
+		"preview_url",
+		"previewUrl",
+		"url"
+	]);
+}
+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;
+}
+function parseWranglerVersionUploadOutput(output) {
+	const parsed = parseJsonObject(output);
+	const versionId = findVersionIdInUploadJson(parsed) ?? parseVersionId(output);
+	const previewUrl = findPreviewUrlInUploadJson(parsed) ?? parseWorkersDevUrl(output);
+	if (!versionId) throw new Error("Could not detect Worker version ID from `wrangler versions upload` output.");
+	return {
+		versionId,
+		previewUrl,
+		output
+	};
+}
+function buildWranglerVersionUploadArgs(options) {
+	const args = ["versions", "upload"];
+	const env = options.env || (options.preview ? "preview" : void 0);
+	if (options.config) args.push("--config", options.config);
+	if (options.name) args.push("--name", options.name);
+	if (env) args.push("--env", validateWranglerEnvName(env));
+	if (options.previewAlias) args.push("--preview-alias", options.previewAlias);
+	return {
+		args,
+		env
+	};
+}
+function buildWranglerVersionDeployArgs(versionTraffic, options) {
+	const args = [
+		"versions",
+		"deploy",
+		...versionTraffic.map(({ versionId, percentage }) => `${versionId}@${percentage}%`),
+		"--yes"
+	];
+	const env = options.env || (options.preview ? "preview" : void 0);
+	if (options.config) args.push("--config", options.config);
+	if (options.name) args.push("--name", options.name);
+	if (env) args.push("--env", validateWranglerEnvName(env));
+	return {
+		args,
+		env
+	};
+}
+function buildWranglerDeploymentsStatusArgs(options) {
+	const args = [
+		"deployments",
+		"status",
+		"--json"
+	];
+	const env = options.env || (options.preview ? "preview" : void 0);
+	if (options.config) args.push("--config", options.config);
+	if (options.name) args.push("--name", options.name);
+	if (env) args.push("--env", validateWranglerEnvName(env));
+	return {
+		args,
+		env
+	};
+}
+function buildWranglerTriggersDeployArgs(options) {
+	const args = ["triggers", "deploy"];
+	const env = options.env || (options.preview ? "preview" : void 0);
+	if (options.config) args.push("--config", options.config);
+	if (options.name) args.push("--name", options.name);
+	if (env) args.push("--env", validateWranglerEnvName(env));
+	return {
+		args,
+		env
+	};
+}
+function runWranglerCommand(root, args, execute = execFileSync) {
+	const invocation = buildNodeCliInvocation(resolveWranglerBin(root), args);
+	const execOpts = {
+		cwd: root,
+		stdio: "pipe",
+		encoding: "utf-8",
+		shell: false
+	};
+	const output = execute(invocation.file, invocation.args, execOpts);
+	if (output.trim()) for (const line of output.trim().split("\n")) console.log(`  ${line}`);
+	return output;
+}
+function errorText(error) {
+	if (!error || typeof error !== "object") return String(error);
+	const parts = error instanceof Error ? [error.message] : [];
+	const record = error;
+	for (const field of [
+		"stdout",
+		"stderr",
+		"output"
+	]) {
+		const value = record[field];
+		if (Array.isArray(value)) parts.push(...value.filter((entry) => typeof entry === "string" || Buffer.isBuffer(entry)).map((entry) => entry.toString()));
+		else if (typeof value === "string" || Buffer.isBuffer(value)) parts.push(value.toString());
+	}
+	return parts.join("\n");
+}
+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.");
+}
+function parseDeploymentVersions(value) {
+	const deployment = Array.isArray(value) ? value.at(-1) : value;
+	if (!isRecord(deployment) || !Array.isArray(deployment.versions)) return [];
+	const versions = [];
+	for (const version of deployment.versions) {
+		if (!isRecord(version)) continue;
+		const versionId = version.version_id;
+		const percentage = version.percentage;
+		if (typeof versionId !== "string" || typeof percentage !== "number") continue;
+		versions.push({
+			versionId,
+			percentage
+		});
+	}
+	return versions;
+}
+function parseWranglerDeploymentStatusOutput(output) {
+	const parsed = parseJsonObject(output);
+	if (!parsed) throw new Error("Could not parse `wrangler deployments status --json` output.");
+	return {
+		versions: parseDeploymentVersions(parsed),
+		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));
+	} catch (error) {
+		if (isMissingWorkerVersionUploadError(error)) throw withInitialDeployRequiredMessage();
+		throw error;
+	}
+}
+function runWranglerVersionDeploy(root, versionTraffic, options, phase = "promote-uploaded", execute = execFileSync) {
+	const { args, env } = buildWranglerVersionDeployArgs(versionTraffic, options);
+	const target = env ? `env: ${env}` : "production";
+	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);
+	return {
+		deployedUrl: parseWorkersDevUrl(output),
+		output
+	};
+}
+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));
+}
+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);
+	return {
+		deployedUrl: parseWorkersDevUrl(output),
+		output
+	};
+}
+//#endregion
+export { buildWranglerDeploymentsStatusArgs, buildWranglerTriggersDeployArgs, buildWranglerVersionDeployArgs, buildWranglerVersionUploadArgs, parseVersionId, parseWorkersDevUrl, parseWranglerDeploymentStatusOutput, parseWranglerVersionUploadOutput, runWranglerDeploymentStatus, runWranglerTriggersDeploy, runWranglerVersionDeploy, runWranglerVersionUpload };

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

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

package/dist/workers-dev-url.js

@@ -0,0 +1,42 @@
+//#region src/workers-dev-url.ts
+function parseWorkersDevUrl(output) {
+	for (const rawToken of splitWhitespace(output)) {
+		const candidate = trimUrlPunctuation(rawToken);
+		if (!candidate.startsWith("https://")) continue;
+		try {
+			const url = new URL(candidate);
+			if (url.protocol !== "https:") continue;
+			if (url.hostname !== "workers.dev" && !url.hostname.endsWith(".workers.dev")) continue;
+			if (url.pathname === "/" && url.search === "" && url.hash === "") return url.origin;
+			return url.toString();
+		} catch {
+			continue;
+		}
+	}
+	return null;
+}
+function splitWhitespace(value) {
+	const tokens = [];
+	let tokenStart = null;
+	for (let i = 0; i < value.length; i++) {
+		const char = value[i];
+		if (char === void 0) continue;
+		if (char.trim() === "") {
+			if (tokenStart !== null) {
+				tokens.push(value.slice(tokenStart, i));
+				tokenStart = null;
+			}
+		} else if (tokenStart === null) tokenStart = i;
+	}
+	if (tokenStart !== null) tokens.push(value.slice(tokenStart));
+	return tokens;
+}
+function trimUrlPunctuation(value) {
+	let start = 0;
+	let end = value.length;
+	while (start < end && "\"'(<".includes(value[start])) start++;
+	while (end > start && "\"')>.,;".includes(value[end - 1])) end--;
+	return value.slice(start, end);
+}
+//#endregion
+export { parseWorkersDevUrl };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vinext/cloudflare",
-  "version": "0.2.0",
+  "version": "1.0.0-beta.0",
   "description": "Cloudflare adapters for vinext (KV data cache and Images-backed image optimization).",
   "license": "MIT",
   "repository": {
@@ -33,6 +33,14 @@
       "types": "./dist/tpr.d.ts",
       "import": "./dist/tpr.js"
     },
+    "./internal/cdn-warm": {
+      "types": "./dist/cdn-warm.d.ts",
+      "import": "./dist/cdn-warm.js"
+    },
+    "./internal/version-deploy": {
+      "types": "./dist/version-deploy.d.ts",
+      "import": "./dist/version-deploy.js"
+    },
     "./cache/*": {
       "types": "./dist/cache/*.d.ts",
       "import": "./dist/cache/*.js"
@@ -45,7 +53,7 @@
   "devDependencies": {
     "@types/node": "^25.9.2",
     "vite-plus": "0.2.1",
-    "vinext": "0.2.0"
+    "vinext": "1.0.0-beta.0"
   },
   "peerDependencies": {
     "vinext": ">=0.0.0"