void 0.10.13 → 0.20.1

package/dist/cloudflare-operations-CPTpRW6d.mjs

@@ -0,0 +1,566 @@
+import { n as __exportAll } from "./rolldown-runtime-rQ84J-ij.mjs";
+import { o as join } from "./dist-BrsS7cai.mjs";
+import { A as writeWranglerPublishedTrafficSnapshot, O as updateWranglerCustomDomain, S as readWranglerPublishedTrafficSnapshot, b as readWranglerCustomDomains } from "./wrangler--imS8n0d.mjs";
+import { r as scanWranglerDotenvKeys } from "./dotenv-VQxupEUv.mjs";
+import { o as resolveWranglerArgv } from "./preset-lAy0B0BQ.mjs";
+import { i as provisionEnv, o as resolvePinnedApiBaseUrl, r as deleteEnvVarCaseAware, t as assertNoTransportRedirectInProjectDotenv } from "./provision-Blnstcm2.mjs";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { spawnSync } from "node:child_process";
+import { deployCloudflareVersionTraffic, encodeCloudflareVersionMessage, parseCloudflareVersionMessage, parseRootWranglerConfig, readBindingFieldPresence, readCloudflareTriggerConfig, readWranglerTopLevelString, resolveD1MigrateTarget, stabilizeCloudflareVersionTriggers } from "@void/deploy-cloudflare";
+//#region src/cli/cloudflare-operations.ts
+var cloudflare_operations_exports = /* @__PURE__ */ __exportAll({
+	activateCloudflareExistingVersion: () => activateCloudflareExistingVersion,
+	applyCloudflareD1Migrations: () => applyCloudflareD1Migrations,
+	changeCloudflareDomain: () => changeCloudflareDomain,
+	createCloudflareEmptyDomainPublisher: () => createCloudflareEmptyDomainPublisher,
+	deleteCloudflareSecret: () => deleteCloudflareSecret,
+	executeCloudflareD1Sql: () => executeCloudflareD1Sql,
+	listCloudflareDomains: () => listCloudflareDomains,
+	listCloudflareSecrets: () => listCloudflareSecrets,
+	parseActiveVersionId: () => parseActiveVersionId,
+	parseCloudflareDeployedVersionIds: () => parseCloudflareDeployedVersionIds,
+	parseCloudflareVersions: () => parseCloudflareVersions,
+	publishEmptyCloudflareCustomDomainSet: () => publishEmptyCloudflareCustomDomainSet,
+	putCloudflareSecret: () => putCloudflareSecret,
+	readCloudflareD1Migrations: () => readCloudflareD1Migrations,
+	readCloudflareWorkerStatus: () => readCloudflareWorkerStatus,
+	resolveCloudflareD1Context: () => resolveCloudflareD1Context,
+	resolveCloudflareOperationContext: () => resolveCloudflareOperationContext,
+	syncCloudflareSecrets: () => syncCloudflareSecrets,
+	tailCloudflareWorker: () => tailCloudflareWorker
+});
+function resolveCloudflareOperationContext(root, runner) {
+	const configPath = discoverRootWranglerConfig(root);
+	if (!existsSync(configPath)) throw new Error(`No Cloudflare config found at "${configPath}". Run \`void init\` first.`);
+	assertNoOperationConfigOverride(root);
+	assertNoTransportRedirectInProjectDotenv(root);
+	const config = parseRootWranglerConfig(configPath);
+	const workerName = readWranglerTopLevelString(config, "name");
+	if (!workerName) throw new Error(`Cloudflare config "${configPath}" has no worker name. Run \`void init\` first.`);
+	const accountId = readWranglerTopLevelString(config, "account_id") ?? (process.env.CLOUDFLARE_ACCOUNT_ID?.trim() || void 0);
+	if (!accountId) throw new Error("No Cloudflare account is pinned. Set account_id in wrangler.jsonc or CLOUDFLARE_ACCOUNT_ID.");
+	const apiBaseUrl = resolvePinnedApiBaseUrl(process.env, readWranglerTopLevelString(config, "compliance_region"));
+	return {
+		accountId,
+		apiBaseUrl,
+		configPath,
+		workerName,
+		runWrangler: runner ?? createCloudflareOperationRunner(root, accountId, apiBaseUrl)
+	};
+}
+async function listCloudflareSecrets(context) {
+	const parsed = parseJson((await run(context, [
+		"secret",
+		"list",
+		...targetArgs(context),
+		"--format",
+		"json"
+	])).stdout, "Cloudflare secret list");
+	if (!Array.isArray(parsed)) throw new Error("Cloudflare secret list returned an unexpected response.");
+	return parsed.map((entry) => {
+		if (typeof entry !== "object" || entry === null) return null;
+		const value = entry;
+		return typeof value.name === "string" ? value.name : null;
+	}).filter((name) => name !== null).sort();
+}
+async function putCloudflareSecret(context, name, value) {
+	await run(context, [
+		"secret",
+		"put",
+		name,
+		...targetArgs(context)
+	], { input: value });
+}
+async function syncCloudflareSecrets(context, secrets) {
+	const values = Object.fromEntries(secrets.map(({ name, value }) => [name, value]));
+	await run(context, [
+		"secret",
+		"bulk",
+		...targetArgs(context)
+	], { input: `${JSON.stringify(values)}\n` });
+}
+async function deleteCloudflareSecret(context, name) {
+	await run(context, [
+		"secret",
+		"delete",
+		name,
+		...targetArgs(context)
+	]);
+}
+function resolveCloudflareD1Context(root, binding, runner) {
+	const operation = resolveCloudflareOperationContext(root, runner);
+	const config = parseRootWranglerConfig(operation.configPath);
+	const target = resolveD1MigrateTarget(config, binding);
+	if (!target.ok) throw new Error(`Cannot resolve D1 binding ${binding}: ${target.reason}.`);
+	const migrationsDir = readBindingFieldPresence(config, "d1_databases", binding, "migrations_dir");
+	const migrationsTable = readBindingFieldPresence(config, "d1_databases", binding, "migrations_table");
+	if (migrationsDir.present && (typeof migrationsDir.value !== "string" || migrationsDir.value.length === 0)) throw new Error(`D1 binding ${binding} has an invalid migrations_dir.`);
+	if (migrationsTable.present && (typeof migrationsTable.value !== "string" || migrationsTable.value.length === 0)) throw new Error(`D1 binding ${binding} has an invalid migrations_table.`);
+	return {
+		operation,
+		binding,
+		migrateToken: target.token,
+		migrationsDir: migrationsDir.present ? migrationsDir.value : "db/migrations",
+		migrationsTable: migrationsTable.present ? migrationsTable.value : "d1_migrations"
+	};
+}
+async function executeCloudflareD1Sql(context, sql) {
+	const parsed = parseJson((await run(context.operation, [
+		"d1",
+		"execute",
+		context.migrateToken,
+		"--remote",
+		"--command",
+		sql,
+		"--json",
+		"-c",
+		context.operation.configPath,
+		"--env="
+	])).stdout, "Cloudflare D1 execute");
+	if (!Array.isArray(parsed)) throw new Error("Cloudflare D1 execute returned an unexpected response.");
+	const rows = [];
+	for (const item of parsed) {
+		if (typeof item !== "object" || item === null) throw new Error("Cloudflare D1 execute returned a malformed result.");
+		const resultRows = item.results;
+		if (!Array.isArray(resultRows)) continue;
+		for (const row of resultRows) if (typeof row === "object" && row !== null && !Array.isArray(row)) rows.push(row);
+	}
+	return rows;
+}
+async function readCloudflareD1Migrations(context) {
+	const table = context.migrationsTable.replace(/"/g, "\"\"");
+	try {
+		return (await executeCloudflareD1Sql(context, `SELECT name FROM "${table}" ORDER BY name`)).map((row) => typeof row.name === "string" ? row.name : null).filter((name) => name !== null);
+	} catch (error) {
+		if (/no such table/i.test(errorMessage(error))) return [];
+		throw error;
+	}
+}
+async function applyCloudflareD1Migrations(context) {
+	await run(context.operation, [
+		"d1",
+		"migrations",
+		"apply",
+		context.migrateToken,
+		"--remote",
+		"-c",
+		context.operation.configPath,
+		"--env="
+	], { capture: false });
+}
+async function readCloudflareWorkerStatus(context) {
+	const [deployment, deployments, versions] = await Promise.all([
+		run(context, [
+			"deployments",
+			"status",
+			...targetArgs(context),
+			"--json"
+		]),
+		run(context, [
+			"deployments",
+			"list",
+			...targetArgs(context),
+			"--json"
+		]),
+		run(context, [
+			"versions",
+			"list",
+			...targetArgs(context),
+			"--json"
+		])
+	]);
+	const activeVersionId = parseActiveVersionId(deployment.stdout);
+	const deployedVersionIds = parseCloudflareDeployedVersionIds(deployments.stdout);
+	if (activeVersionId && !deployedVersionIds.includes(activeVersionId)) deployedVersionIds.push(activeVersionId);
+	return {
+		workerName: context.workerName,
+		activeVersionId,
+		deployedVersionIds,
+		versions: parseCloudflareVersions(versions.stdout)
+	};
+}
+/** Return only versions that Cloudflare records as members of a production deployment. */
+function parseCloudflareDeployedVersionIds(value) {
+	const parsed = parseJson(value, "Cloudflare deployment list");
+	if (!Array.isArray(parsed)) throw new Error("Cloudflare deployment list returned an unexpected response.");
+	const ids = /* @__PURE__ */ new Set();
+	parsed.forEach((deployment, deploymentIndex) => {
+		if (typeof deployment !== "object" || deployment === null || !Array.isArray(deployment.versions)) throw new Error(`Cloudflare deployment list entry ${deploymentIndex + 1} is malformed.`);
+		for (const version of deployment.versions) {
+			if (typeof version !== "object" || version === null || typeof version.version_id !== "string" || typeof version.percentage !== "number" || !Number.isFinite(version.percentage) || version.percentage < 0 || version.percentage > 100) throw new Error(`Cloudflare deployment list entry ${deploymentIndex + 1} is malformed.`);
+			if (version.percentage > 0) ids.add(version.version_id);
+		}
+	});
+	return [...ids];
+}
+function parseCloudflareVersions(value) {
+	const parsed = parseJson(value, "Cloudflare version list");
+	if (!Array.isArray(parsed)) throw new Error("Cloudflare version list returned an unexpected response.");
+	return parsed.map((entry, index) => {
+		if (typeof entry !== "object" || entry === null || typeof entry.id !== "string") throw new Error(`Cloudflare version list entry ${index + 1} is malformed.`);
+		const metadata = typeof entry.metadata === "object" && entry.metadata !== null ? entry.metadata : void 0;
+		const annotations = typeof entry.annotations === "object" && entry.annotations !== null ? entry.annotations : void 0;
+		const message = typeof annotations?.["workers/message"] === "string" ? annotations["workers/message"] : null;
+		return {
+			id: entry.id,
+			createdAt: typeof metadata?.created_on === "string" ? metadata.created_on : null,
+			message,
+			metadata: parseCloudflareVersionMessage(message)
+		};
+	});
+}
+function parseActiveVersionId(value) {
+	const parsed = parseJson(value, "Cloudflare deployment status");
+	if (typeof parsed !== "object" || parsed === null) throw new Error("Cloudflare deployment status returned an unexpected response.");
+	const deployment = parsed;
+	if (!Array.isArray(deployment.versions)) throw new Error("Cloudflare deployment status returned an unexpected response.");
+	const active = deployment.versions.find((entry) => typeof entry === "object" && entry !== null && Number(entry.percentage) === 100);
+	if (active === void 0) return null;
+	if (typeof active !== "object" || active === null || typeof active.version_id !== "string") throw new Error("Cloudflare deployment status has a malformed active version.");
+	return active.version_id;
+}
+async function activateCloudflareExistingVersion(context, target, current) {
+	if (target.metadata?.schema !== 2 || target.metadata.triggerConfig.preserve || !current || current.metadata?.schema !== 2 || current.metadata.triggerConfig.preserve) {
+		const owner = await readActiveCloudflareVersionId(context);
+		if (current && owner !== current.id) throw new Error("Cloudflare production changed before rollback. Refresh deployment status and retry.");
+		const result = await deployCloudflareVersionTraffic({
+			...context,
+			percentages: [`${target.id}@100`],
+			message: "Void rollback preserving existing routes and triggers."
+		});
+		if (result.status !== 0 || result.signal || result.error) throw new Error("Cloudflare could not complete rollback. Refresh deployment status before retrying.");
+		if (await readActiveCloudflareVersionId(context) !== target.id) throw new Error("Cloudflare rollback was superseded or could not be verified. Refresh deployment status.");
+		return;
+	}
+	const targetTriggerConfig = target.metadata.triggerConfig;
+	const publishedTraffic = readWranglerPublishedTrafficSnapshot(context.configPath);
+	const currentTriggerConfig = current?.metadata?.schema === 2 ? publishedTraffic ? {
+		...current.metadata.triggerConfig,
+		...publishedTraffic
+	} : current.metadata.triggerConfig : void 0;
+	const message = encodeCloudflareVersionMessage(target.metadata.migrations, targetTriggerConfig);
+	const expectedVersionId = current?.id ?? await readActiveCloudflareVersionId(context);
+	const ownerBeforeActivation = await readActiveCloudflareVersionId(context);
+	if (ownerBeforeActivation !== expectedVersionId) throw new Error(`Cloudflare production changed from ${expectedVersionId ?? "no active version"} to ${ownerBeforeActivation ?? "no active version"} before rollback activation. Retry from fresh deployment status.`);
+	await run(context, [
+		"versions",
+		"deploy",
+		`${target.id}@100`,
+		...targetArgs(context),
+		"--message",
+		message,
+		"--yes"
+	], { capture: false });
+	const knownTriggerConfigs = { [target.id]: targetTriggerConfig };
+	if (currentTriggerConfig && current) knownTriggerConfigs[current.id] = currentTriggerConfig;
+	const triggers = await stabilizeCloudflareVersionTriggers({
+		runWrangler: context.runWrangler,
+		workerName: context.workerName,
+		configPath: context.configPath,
+		targetVersionId: target.id,
+		targetTriggerConfig,
+		previousTriggerConfig: currentTriggerConfig,
+		knownTriggerConfigs,
+		publishEmptyCustomDomains: createCloudflareEmptyDomainPublisher(context)
+	});
+	if (triggers.ok && triggers.targetOwnsTraffic) {
+		writeWranglerPublishedTrafficSnapshot(context.configPath, {
+			workers_dev: targetTriggerConfig.workers_dev,
+			preview_urls: targetTriggerConfig.preview_urls,
+			routes: [...targetTriggerConfig.routes]
+		});
+		return;
+	}
+	if (triggers.ok) throw new Error(`Cloudflare rollback to ${target.id} was superseded by ${triggers.activeVersionId}; Void restored the active version's triggers. Refresh deployment status before retrying.`);
+	if (triggers.activeVersionId && triggers.activeVersionId !== target.id) throw new Error(`Cloudflare rollback to ${target.id} was superseded by ${triggers.activeVersionId}, but Void could not restore that version's triggers (${triggers.reason}). Inspect the Worker immediately.`);
+	if (!triggers.activeVersionId) throw new Error(`Cloudflare activated ${target.id}, but Void could not verify which version owns production while synchronizing triggers (${triggers.reason}). Inspect the Worker immediately.`);
+	if (!currentTriggerConfig || !current) throw new Error(`Cloudflare activated version ${target.id}, but trigger synchronization failed and no prior trigger snapshot was available. Inspect the Worker immediately.`);
+	const ownerBeforeCompensation = await readActiveCloudflareVersionId(context);
+	if (ownerBeforeCompensation !== target.id) {
+		const repair = await stabilizeCloudflareVersionTriggers({
+			runWrangler: context.runWrangler,
+			workerName: context.workerName,
+			configPath: context.configPath,
+			targetVersionId: target.id,
+			targetTriggerConfig,
+			previousTriggerConfig: currentTriggerConfig,
+			knownTriggerConfigs,
+			publishEmptyCustomDomains: createCloudflareEmptyDomainPublisher(context)
+		});
+		throw new Error(repair.ok ? `Cloudflare rollback to ${target.id} was superseded by ${repair.activeVersionId}; Void restored the active version's triggers. Refresh deployment status before retrying.` : `Cloudflare rollback to ${target.id} was superseded by ${ownerBeforeCompensation ?? "an unknown version"}, but Void could not restore the active triggers (${repair.reason}). Inspect the Worker immediately.`);
+	}
+	let recoveryFailure = null;
+	try {
+		await run(context, [
+			"versions",
+			"deploy",
+			`${current.id}@100`,
+			...targetArgs(context),
+			"--message",
+			`Void automatic rollback after trigger synchronization failed.`,
+			"--yes"
+		], { capture: false });
+		const restoredTriggers = await stabilizeCloudflareVersionTriggers({
+			runWrangler: context.runWrangler,
+			workerName: context.workerName,
+			configPath: context.configPath,
+			targetVersionId: current.id,
+			targetTriggerConfig: currentTriggerConfig,
+			previousTriggerConfig: targetTriggerConfig,
+			knownTriggerConfigs,
+			publishEmptyCustomDomains: createCloudflareEmptyDomainPublisher(context)
+		});
+		if (!restoredTriggers.ok) recoveryFailure = "previous trigger synchronization failed";
+		else if (!restoredTriggers.targetOwnsTraffic) recoveryFailure = `recovery was superseded by ${restoredTriggers.activeVersionId}`;
+		else writeWranglerPublishedTrafficSnapshot(context.configPath, {
+			workers_dev: currentTriggerConfig.workers_dev,
+			preview_urls: currentTriggerConfig.preview_urls,
+			routes: [...currentTriggerConfig.routes]
+		});
+	} catch (error) {
+		recoveryFailure = errorMessage(error);
+	}
+	throw new Error(recoveryFailure ? `Cloudflare trigger synchronization failed after activating ${target.id}, and automatic recovery also failed: ${recoveryFailure}` : `Cloudflare trigger synchronization failed after activating ${target.id}; traffic and triggers were restored to ${current.id}.`);
+}
+async function readActiveCloudflareVersionId(context) {
+	return parseActiveVersionId((await run(context, [
+		"deployments",
+		"status",
+		...targetArgs(context),
+		"--json"
+	])).stdout);
+}
+async function tailCloudflareWorker(context, options) {
+	const args = [
+		"tail",
+		context.workerName,
+		"-c",
+		context.configPath,
+		"--env=",
+		"--format",
+		"pretty"
+	];
+	if (options.filter) args.push("--search", options.filter);
+	if (options.versionId) args.push("--version-id", options.versionId);
+	if (options.status) args.push("--status", options.status);
+	await run(context, args, { capture: false });
+}
+function listCloudflareDomains(root) {
+	return readWranglerCustomDomains(root).domains;
+}
+async function changeCloudflareDomain(root, hostname, action, runner, emptyDomainPublisher) {
+	const context = resolveCloudflareOperationContext(root, runner);
+	const before = readWranglerCustomDomains(root);
+	const original = readFileSync(before.configPath, "utf-8");
+	const update = updateWranglerCustomDomain(root, hostname, action);
+	if (!update.modified) return update;
+	if (update.domains.length === 0 && !emptyDomainPublisher && !resolveCloudflareApiToken()) {
+		writeFileSync(before.configPath, original);
+		throw new Error("Deleting the final Cloudflare custom domain requires CLOUDFLARE_API_TOKEN because Wrangler cannot reconcile an empty custom-domain set. Export a scoped token with Workers Scripts: Edit permission and retry. No local or remote state changed.");
+	}
+	const triggerConfigDir = mkdtempSync(join(tmpdir(), "void-domain-triggers-"));
+	const triggerConfigPath = join(triggerConfigDir, "wrangler.json");
+	const deployRoutes = async () => {
+		if (readWranglerCustomDomains(root).domains.length === 0) {
+			await (emptyDomainPublisher ?? publishEmptyCloudflareCustomDomainSet)(context);
+			return;
+		}
+		writeDomainTriggerConfig(context, before.configPath, triggerConfigPath);
+		await run(context, [
+			"triggers",
+			"deploy",
+			"-c",
+			triggerConfigPath,
+			"--env=",
+			"--name",
+			context.workerName
+		], { capture: false });
+	};
+	try {
+		await deployRoutes();
+	} catch (error) {
+		writeFileSync(before.configPath, original);
+		try {
+			await deployRoutes();
+		} catch (restoreError) {
+			throw new Error(`Cloudflare rejected the domain trigger update and also rejected the automatic remote restore. The local Wrangler config was restored, but remote route state may be partially applied. ${errorMessage(error)} Restore failed: ${errorMessage(restoreError)}`);
+		}
+		throw new Error(`Cloudflare rejected the domain trigger update; both the local config and remote triggers were restored. ${errorMessage(error)}`);
+	} finally {
+		rmSync(triggerConfigDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	const publishedTraffic = readCloudflareTriggerConfig(before.configPath);
+	writeWranglerPublishedTrafficSnapshot(before.configPath, {
+		workers_dev: publishedTraffic.workers_dev,
+		preview_urls: publishedTraffic.preview_urls,
+		routes: [...publishedTraffic.routes]
+	});
+	return update;
+}
+/**
+* Reconcile an empty Custom Domain set through the API Wrangler itself uses.
+* Wrangler 4.130 skips `publishCustomDomains()` when its configured set is
+* empty, so `triggers deploy` exits successfully without removing the final
+* domain. Direct API access is deliberately limited to an explicit API token;
+* OAuth credential storage is Wrangler-private and must not be scraped.
+*/
+async function publishEmptyCloudflareCustomDomainSet(context) {
+	const token = resolveCloudflareApiToken();
+	if (!token) throw new Error("CLOUDFLARE_API_TOKEN is required to restore an empty custom-domain set after Wrangler failed.");
+	const response = await fetch(`${context.apiBaseUrl}/accounts/${context.accountId}/workers/scripts/${context.workerName}/domains/records`, {
+		method: "PUT",
+		headers: {
+			Authorization: `Bearer ${token}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({
+			override_scope: true,
+			override_existing_origin: false,
+			override_existing_dns_record: false,
+			origins: []
+		}),
+		redirect: "error",
+		signal: AbortSignal.timeout(3e4)
+	});
+	let body;
+	try {
+		body = await response.json();
+	} catch {
+		throw new Error(`Cloudflare returned HTTP ${response.status} with a non-JSON custom-domain response.`);
+	}
+	if (!response.ok || typeof body !== "object" || body === null || body.success !== true) throw new Error(`Cloudflare rejected the empty custom-domain set (HTTP ${response.status}).`);
+}
+/** Adapt the direct empty-domain API call to the deployment package's result contract. */
+function createCloudflareEmptyDomainPublisher(context) {
+	return async () => {
+		try {
+			await publishEmptyCloudflareCustomDomainSet(context);
+			return {
+				status: 0,
+				stdout: "",
+				stderr: ""
+			};
+		} catch (error) {
+			return {
+				status: 1,
+				stdout: "",
+				stderr: errorMessage(error),
+				error: errorMessage(error)
+			};
+		}
+	};
+}
+function resolveCloudflareApiToken() {
+	return process.env.CLOUDFLARE_API_TOKEN || process.env.CF_API_TOKEN || void 0;
+}
+/**
+* Build a route-only Wrangler config for a domain update. `triggers deploy`
+* also reconciles cron, queue-consumer, and workflow triggers found in its
+* config, so using the root config here could drop generated schedules or
+* replay stale consumers. The isolated config carries only the route surface
+* this command owns and the workers.dev switches that route reconciliation
+* also evaluates.
+*/
+function writeDomainTriggerConfig(context, sourceConfigPath, triggerConfigPath) {
+	const source = parseRootWranglerConfig(sourceConfigPath);
+	const config = {
+		name: context.workerName,
+		account_id: context.accountId,
+		routes: Array.isArray(source.routes) ? source.routes : []
+	};
+	for (const field of ["workers_dev", "preview_urls"]) if (typeof source[field] === "boolean") config[field] = source[field];
+	const compatibilityDate = readWranglerTopLevelString(source, "compatibility_date");
+	if (compatibilityDate) config.compatibility_date = compatibilityDate;
+	writeFileSync(triggerConfigPath, `${JSON.stringify(config, null, 2)}\n`);
+}
+function targetArgs(context) {
+	return [
+		"-c",
+		context.configPath,
+		"--env=",
+		"--name",
+		context.workerName
+	];
+}
+async function run(context, args, options) {
+	const result = await Promise.resolve(context.runWrangler(args, {
+		capture: options?.capture ?? true,
+		input: options?.input
+	}));
+	if (result.status !== 0 || result.signal != null || result.error !== void 0 && result.error !== null && result.error !== "") {
+		const detail = result.stderr.trim() || result.stdout.trim() || result.error || "unknown error";
+		throw new Error(`Wrangler failed (${args.slice(0, 2).join(" ")}, exit ${result.status}): ${detail}`);
+	}
+	return result;
+}
+function createCloudflareOperationRunner(root, accountId, apiBaseUrl) {
+	const [command, ...prefix] = resolveWranglerArgv(root);
+	return (args, options) => {
+		const env = provisionEnv({
+			accountId,
+			apiBaseUrl
+		});
+		deleteEnvVarCaseAware(env, "WRANGLER_CI_OVERRIDE_NAME");
+		if (!options.capture) env.WRANGLER_LOG = "none";
+		const result = spawnSync(command, [...prefix, ...args], {
+			cwd: root,
+			env,
+			shell: false,
+			windowsHide: true,
+			encoding: "utf-8",
+			input: options.input,
+			stdio: options.input !== void 0 ? [
+				"pipe",
+				options.capture ? "pipe" : "inherit",
+				options.capture ? "pipe" : "inherit"
+			] : options.capture ? [
+				"ignore",
+				"pipe",
+				"pipe"
+			] : "inherit"
+		});
+		return {
+			status: typeof result.status === "number" ? result.status : 1,
+			stdout: result.stdout ?? "",
+			stderr: result.stderr ?? "",
+			signal: result.signal ?? null,
+			error: result.error?.message ?? null
+		};
+	};
+}
+function discoverRootWranglerConfig(root) {
+	for (const name of ["wrangler.jsonc", "wrangler.json"]) {
+		const path = join(root, name);
+		if (existsSync(path)) return path;
+	}
+	return join(root, "wrangler.jsonc");
+}
+function assertNoOperationConfigOverride(root) {
+	if (process.env.CLOUDFLARE_ENV?.trim()) throw new Error("CLOUDFLARE_ENV is set. Void Cloudflare operations target the top-level config only.");
+	if (process.env.CLOUDFLARE_VITE_WRANGLER_CONFIG_PATH?.trim()) throw new Error("CLOUDFLARE_VITE_WRANGLER_CONFIG_PATH is set. Void Cloudflare operations use the root Wrangler config only.");
+	for (const file of [
+		".env",
+		".env.local",
+		".env.",
+		".env..local"
+	]) {
+		const keys = scanWranglerDotenvKeys(join(root, file));
+		if (process.platform === "win32" ? [...keys].some((key) => key.toLowerCase() === "wrangler_ci_override_name") : keys.has("WRANGLER_CI_OVERRIDE_NAME")) throw new Error(`Project file "${file}" sets WRANGLER_CI_OVERRIDE_NAME, which can replace the pinned Worker name. Remove it before running this command.`);
+	}
+}
+function parseJson(value, label) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		throw new Error(`${label} did not return valid JSON.`);
+	}
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export { createCloudflareEmptyDomainPublisher as n, cloudflare_operations_exports as t };