void 0.22.0 → 0.23.0

package/dist/{cloudflare-connect-Ctmrw579.mjs → cloudflare-connect-B8uPZ4nx.mjs}

@@ -1,7 +1,7 @@
 import { a as join, t as basename } from "./dist-BVqXeR_h.mjs";
-import { i as LATEST_KNOWN_COMPAT_DATE, k as writeProvisionedWranglerConfig, v as readRootWranglerConfig } from "./wrangler-DQF1vKyf.mjs";
+import { A as writeProvisionedWranglerConfig, i as LATEST_KNOWN_COMPAT_DATE, y as readRootWranglerConfig } from "./wrangler-7K-bW_DL.mjs";
 import { I as select, W as isCancel, j as log } from "./dist-CTBk70IR.mjs";
-import { a as ensureCloudflareAuthentication, i as createBundledCloudflareAuthRunner } from "./cloudflare-auth-DQkqoMYa.mjs";
+import { i as ensureCloudflareAuthentication, r as createBundledCloudflareAuthRunner } from "./cloudflare-auth-Qdc7tw8F.mjs";
 import { existsSync } from "node:fs";
 //#region src/cli/cloudflare-connect.ts
 async function connectCloudflare(root, interactive = Boolean(process.stdin.isTTY)) {
@@ -24,7 +24,7 @@ async function connectCloudflare(root, interactive = Boolean(process.stdin.isTTY
 		interactive,
 		requireAccounts: true,
 		runWrangler: createBundledCloudflareAuthRunner(root),
-		whoamiArgs: existingConfigPath ? ["-c", existingConfigPath] : []
+		configPath: existingConfigPath
 	});
 	let account = accounts.find((entry) => entry.id === pinnedAccount);
 	if (pinnedAccount && !account) throw new Error(`connect: The signed-in Cloudflare session cannot access account ${pinnedAccount}.`);

package/dist/{cloudflare-operations-BT6OWFBk.mjs → cloudflare-operations-AiWashgg.mjs}

@@ -1,2 +1,2 @@
-import { _ as resolveCloudflareD1Context, b as tailCloudflareWorker, c as listCloudflareDomains, g as readCloudflareWorkerStatus, h as readCloudflareD1Migrations, l as listCloudflareSecrets, m as putCloudflareSecret, n as applyCloudflareD1Migrations, o as deleteCloudflareSecret, r as changeCloudflareDomain, s as executeCloudflareD1Sql, t as activateCloudflareExistingVersion, v as resolveCloudflareOperationContext, y as syncCloudflareSecrets } from "./cloudflare-operations-B9tzgjmf.mjs";
+import { _ as resolveCloudflareD1Context, b as tailCloudflareWorker, c as listCloudflareDomains, g as readCloudflareWorkerStatus, h as readCloudflareD1Migrations, l as listCloudflareSecrets, m as putCloudflareSecret, n as applyCloudflareD1Migrations, o as deleteCloudflareSecret, r as changeCloudflareDomain, s as executeCloudflareD1Sql, t as activateCloudflareExistingVersion, v as resolveCloudflareOperationContext, y as syncCloudflareSecrets } from "./cloudflare-operations-fxHb-byx.mjs";
 export { activateCloudflareExistingVersion, applyCloudflareD1Migrations, changeCloudflareDomain, deleteCloudflareSecret, executeCloudflareD1Sql, listCloudflareDomains, listCloudflareSecrets, putCloudflareSecret, readCloudflareD1Migrations, readCloudflareWorkerStatus, resolveCloudflareD1Context, resolveCloudflareOperationContext, syncCloudflareSecrets, tailCloudflareWorker };

package/dist/{cloudflare-operations-B9tzgjmf.mjs → cloudflare-operations-fxHb-byx.mjs}

@@ -1,11 +1,11 @@
 import { a as join } from "./dist-BVqXeR_h.mjs";
-import { A as writeWranglerPublishedTrafficSnapshot, B as materializeCloudflareConfig, O as updateWranglerCustomDomain, S as readWranglerPublishedTrafficSnapshot, V as persistCloudflareConfig, b as readWranglerCustomDomains } from "./wrangler-DQF1vKyf.mjs";
+import { i as persistCloudflareConfig, r as materializeCloudflareConfig } from "./cloudflare-config-Bktvwtpf.mjs";
+import { C as readWranglerPublishedTrafficSnapshot, j as writeWranglerPublishedTrafficSnapshot, k as updateWranglerCustomDomain, x as readWranglerCustomDomains } from "./wrangler-7K-bW_DL.mjs";
 import { r as scanWranglerDotenvKeys } from "./dotenv-VQxupEUv.mjs";
-import { o as resolveWranglerArgv } from "./preset-UHj9ARyP.mjs";
-import { _ as resolvePinnedApiBaseUrl, g as provisionEnv, r as assertNoTransportRedirectInProjectDotenv, s as deleteEnvVarCaseAware } from "./provision-C4IGqkBf.mjs";
+import { t as createCloudflareProcessRunner } from "./cloudflare-process-B-wekeR6.mjs";
+import { _ as resolvePinnedApiBaseUrl, g as provisionEnv, r as assertNoTransportRedirectInProjectDotenv, s as deleteEnvVarCaseAware } from "./provision-CJFgTZY8.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
 function resolveCloudflareOperationContext(root, runner) {
@@ -28,13 +28,11 @@ function resolveCloudflareOperationContext(root, runner) {
 	};
 }
 async function listCloudflareSecrets(context) {
-	const parsed = parseJson((await run(context, [
-		"secret",
-		"list",
-		...targetArgs(context),
-		"--format",
-		"json"
-	])).stdout, "Cloudflare secret list");
+	const parsed = parseJson((await run(context, {
+		type: "secret.list",
+		configPath: context.configPath,
+		workerName: context.workerName
+	})).data, "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;
@@ -43,28 +41,28 @@ async function listCloudflareSecrets(context) {
 	}).filter((name) => name !== null).sort();
 }
 async function putCloudflareSecret(context, name, value) {
-	await run(context, [
-		"secret",
-		"put",
+	await run(context, {
+		type: "secret.put",
 		name,
-		...targetArgs(context)
-	], { input: value });
+		configPath: context.configPath,
+		workerName: context.workerName
+	}, { 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` });
+	await run(context, {
+		type: "secret.bulk",
+		configPath: context.configPath,
+		workerName: context.workerName
+	}, { input: `${JSON.stringify(values)}\n` });
 }
 async function deleteCloudflareSecret(context, name) {
-	await run(context, [
-		"secret",
-		"delete",
+	await run(context, {
+		type: "secret.delete",
 		name,
-		...targetArgs(context)
-	]);
+		configPath: context.configPath,
+		workerName: context.workerName
+	});
 }
 function resolveCloudflareD1Context(root, binding, runner) {
 	const operation = resolveCloudflareOperationContext(root, runner);
@@ -84,18 +82,12 @@ function resolveCloudflareD1Context(root, binding, runner) {
 	};
 }
 async function executeCloudflareD1Sql(context, sql) {
-	const parsed = parseJson((await run(context.operation, [
-		"d1",
-		"execute",
-		context.migrateToken,
-		"--remote",
-		"--command",
+	const parsed = parseJson((await run(context.operation, {
+		type: "d1.execute",
+		database: context.migrateToken,
 		sql,
-		"--json",
-		"-c",
-		context.operation.configPath,
-		"--env="
-	])).stdout, "Cloudflare D1 execute");
+		configPath: context.operation.configPath
+	})).data, "Cloudflare D1 execute");
 	if (!Array.isArray(parsed)) throw new Error("Cloudflare D1 execute returned an unexpected response.");
 	const rows = [];
 	for (const item of parsed) {
@@ -116,46 +108,38 @@ async function readCloudflareD1Migrations(context) {
 	}
 }
 async function applyCloudflareD1Migrations(context) {
-	await run(context.operation, [
-		"d1",
-		"migrations",
-		"apply",
-		context.migrateToken,
-		"--remote",
-		"-c",
-		context.operation.configPath,
-		"--env="
-	], { capture: false });
+	await run(context.operation, {
+		type: "d1.migrations.apply",
+		database: context.migrateToken,
+		configPath: context.operation.configPath
+	}, { 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"
-		])
+		run(context, {
+			type: "deployments.status",
+			configPath: context.configPath,
+			workerName: context.workerName
+		}),
+		run(context, {
+			type: "deployments.list",
+			configPath: context.configPath,
+			workerName: context.workerName
+		}),
+		run(context, {
+			type: "versions.list",
+			configPath: context.configPath,
+			workerName: context.workerName
+		})
 	]);
-	const activeVersionId = parseActiveVersionId(deployment.stdout);
-	const deployedVersionIds = parseCloudflareDeployedVersionIds(deployments.stdout);
+	const activeVersionId = parseActiveVersionId(deployment.data);
+	const deployedVersionIds = parseCloudflareDeployedVersionIds(deployments.data);
 	if (activeVersionId && !deployedVersionIds.includes(activeVersionId)) deployedVersionIds.push(activeVersionId);
 	return {
 		workerName: context.workerName,
 		activeVersionId,
 		deployedVersionIds,
-		versions: parseCloudflareVersions(versions.stdout)
+		versions: parseCloudflareVersions(versions.data)
 	};
 }
 /** Return only versions that Cloudflare records as members of a production deployment. */
@@ -221,15 +205,16 @@ async function activateCloudflareExistingVersion(context, target, current) {
 	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 });
+	await run(context, {
+		type: "versions.deploy",
+		versions: [{
+			versionId: target.id,
+			percentage: 100
+		}],
+		configPath: context.configPath,
+		workerName: context.workerName,
+		message
+	}, { capture: false });
 	const knownTriggerConfigs = { [target.id]: targetTriggerConfig };
 	if (currentTriggerConfig && current) knownTriggerConfigs[current.id] = currentTriggerConfig;
 	const triggers = await stabilizeCloudflareVersionTriggers({
@@ -272,15 +257,16 @@ async function activateCloudflareExistingVersion(context, target, current) {
 	}
 	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 });
+		await run(context, {
+			type: "versions.deploy",
+			versions: [{
+				versionId: current.id,
+				percentage: 100
+			}],
+			configPath: context.configPath,
+			workerName: context.workerName,
+			message: `Void automatic rollback after trigger synchronization failed.`
+		}, { capture: false });
 		const restoredTriggers = await stabilizeCloudflareVersionTriggers({
 			runWrangler: context.runWrangler,
 			workerName: context.workerName,
@@ -305,27 +291,21 @@ async function activateCloudflareExistingVersion(context, target, current) {
 	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);
+	return parseActiveVersionId((await run(context, {
+		type: "deployments.status",
+		configPath: context.configPath,
+		workerName: context.workerName
+	})).data);
 }
 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 });
+	await run(context, {
+		type: "tail",
+		workerName: context.workerName,
+		configPath: context.configPath,
+		search: options.filter,
+		versionId: options.versionId,
+		status: options.status
+	}, { capture: false });
 }
 function listCloudflareDomains(root) {
 	return readWranglerCustomDomains(root).domains;
@@ -344,15 +324,11 @@ async function changeCloudflareDomain(root, hostname, action, runner, emptyDomai
 			return;
 		}
 		writeDomainTriggerConfig(context, before.configPath, triggerConfigPath);
-		await run(context, [
-			"triggers",
-			"deploy",
-			"-c",
-			triggerConfigPath,
-			"--env=",
-			"--name",
-			context.workerName
-		], { capture: false });
+		await run(context, {
+			type: "triggers.deploy",
+			configPath: triggerConfigPath,
+			workerName: context.workerName
+		}, { capture: false });
 	};
 	try {
 		await deployRoutes();
@@ -385,11 +361,11 @@ async function changeCloudflareDomain(root, hostname, action, runner, emptyDomai
 * explicitly using the same verified browser/API credentials as other commands.
 */
 async function publishEmptyCloudflareCustomDomainSet(context) {
-	await run(context, [
-		"triggers",
-		"clear-domains",
-		...targetArgs(context)
-	]);
+	await run(context, {
+		type: "triggers.clear-domains",
+		configPath: context.configPath,
+		workerName: context.workerName
+	});
 }
 /** Adapt the direct empty-domain API call to the deployment package's result contract. */
 function createCloudflareEmptyDomainPublisher(context) {
@@ -415,11 +391,11 @@ function createCloudflareEmptyDomainPublisher(context) {
 function createCloudflareEmptyCronPublisher(context) {
 	return async () => {
 		try {
-			return await run(context, [
-				"triggers",
-				"clear-crons",
-				...targetArgs(context)
-			]);
+			return await run(context, {
+				type: "triggers.clear-crons",
+				configPath: context.configPath,
+				workerName: context.workerName
+			});
 		} catch (error) {
 			return {
 				status: 1,
@@ -450,15 +426,6 @@ function writeDomainTriggerConfig(context, sourceConfigPath, triggerConfigPath)
 	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,
@@ -466,44 +433,24 @@ async function run(context, args, options) {
 	}));
 	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(`Cloudflare command failed (${args.slice(0, 2).join(" ")}, exit ${result.status}): ${detail}`);
+		throw new Error(`Cloudflare command failed (${args.type}, 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
-		};
-	};
+	return createCloudflareProcessRunner({
+		root,
+		accountId,
+		apiBaseUrl,
+		env: () => {
+			const env = provisionEnv({
+				accountId,
+				apiBaseUrl
+			});
+			deleteEnvVarCaseAware(env, "WRANGLER_CI_OVERRIDE_NAME");
+			return env;
+		}
+	});
 }
 function discoverRootWranglerConfig(root) {
 	return materializeCloudflareConfig(root);
@@ -522,11 +469,8 @@ function assertNoOperationConfigOverride(root) {
 	}
 }
 function parseJson(value, label) {
-	try {
-		return JSON.parse(value);
-	} catch {
-		throw new Error(`${label} did not return valid JSON.`);
-	}
+	if (value === void 0) throw new Error(label + " did not return structured data.");
+	return value;
 }
 function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);

package/dist/{preset-UHj9ARyP.mjs → cloudflare-process-B-wekeR6.mjs}

@@ -1,9 +1,10 @@
 import { a as join, l as relative, n as dirname, u as resolve } from "./dist-BVqXeR_h.mjs";
 import { n as readProjectPaths } from "./project-paths-GgcMozYz.mjs";
-import { i as readPackageJson, n as hasPackageDependency, t as getPackageDependencies } from "./package-json-DXfiT1jV.mjs";
 import { i as hasSsrEntry, r as getSsrServerEntryPath } from "./entry-CF5wvH4w.mjs";
+import { i as readPackageJson, n as hasPackageDependency, t as getPackageDependencies } from "./package-json-DXfiT1jV.mjs";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
 //#region src/cli/preset.ts
 /**
 * Known output conventions for SSGs.
@@ -133,12 +134,12 @@ function shellQuoteExecutable(value) {
 	return `'${value.replace(/'/g, "'\\''")}'`;
 }
 /** Resolve the bundled cf transport without consulting project dependencies. */
-function resolveWranglerArgv(_root) {
+function resolveCloudflareOperationArgv(_root) {
 	const directory = dirname(fileURLToPath(import.meta.url));
 	const entry = [
-		join(directory, "cf-compat.ts"),
-		join(directory, "cf-compat.mjs"),
-		join(directory, "cli", "cf-compat.mjs")
+		join(directory, "cloudflare-operation-process.ts"),
+		join(directory, "cloudflare-operation-process.mjs"),
+		join(directory, "cli", "cloudflare-operation-process.mjs")
 	].find((candidate) => existsSync(candidate));
 	if (!entry) throw new Error(`Void's bundled Cloudflare tooling is unavailable. Reinstall the project's dependencies from its trusted lockfile, then retry.`);
 	return [process.execPath, entry];
@@ -300,4 +301,90 @@ function hasBackendFiles(root) {
 	return false;
 }
 //#endregion
-export { resolveProjectCommand as a, hasBackendFiles as i, detectPreset as n, resolveWranglerArgv as o, formatProjectCommand as r, FRAMEWORK_PRESETS as t };
+//#region src/cli/cloudflare-process.ts
+/** Operations contain public targets only. Secret values travel through stdin. */
+function encodeCloudflareOperation(operation) {
+	return [JSON.stringify(operation)];
+}
+/** Decode the private process envelope once, retaining cancellation provenance. */
+function decodeCloudflareOperationResult(result) {
+	if (result.signal || result.error || result.status === null) return result;
+	if (!result.stdout.trim() && result.status !== 0) return result;
+	try {
+		const value = JSON.parse(result.stdout);
+		if (!value || typeof value !== "object" || Array.isArray(value) || !("operationResult" in value) || value.operationResult !== 1) throw new Error("Invalid operation envelope.");
+		const envelope = value;
+		if (envelope.output !== void 0 && typeof envelope.output !== "string" || envelope.signal != null && typeof envelope.signal !== "string" || envelope.error != null && typeof envelope.error !== "string" || envelope.errorCode !== void 0 && !Number.isSafeInteger(envelope.errorCode) || envelope.failure !== void 0 && ![
+			"not-found",
+			"durable-migration",
+			"containers-unavailable"
+		].includes(envelope.failure) || envelope.errors !== void 0 && (!Array.isArray(envelope.errors) || envelope.errors.some((error) => !error || typeof error !== "object" || typeof error.message !== "string" || error.code !== void 0 && !Number.isSafeInteger(error.code)))) throw new Error("Invalid operation envelope fields.");
+		if (envelope.signal || envelope.error) return {
+			...result,
+			status: 1,
+			stdout: "",
+			signal: envelope.signal,
+			error: envelope.error
+		};
+		return {
+			...result,
+			stdout: envelope.output ?? "",
+			data: envelope.data,
+			errorCode: envelope.errorCode,
+			errors: envelope.errors,
+			failure: envelope.failure
+		};
+	} catch {
+		return {
+			...result,
+			status: 1,
+			stdout: "",
+			stderr: [result.stderr, "Cloudflare tooling returned an invalid operation response."].filter(Boolean).join("\n")
+		};
+	}
+}
+function createCloudflareProcessRunner(options) {
+	const [command, ...prefix] = resolveCloudflareOperationArgv(options.root);
+	return (operation, run) => {
+		const streaming = !run.capture && (operation.type === "auth.login" || operation.type === "tail");
+		const env = typeof options.env === "function" ? options.env() : options.env ?? process.env;
+		const result = spawnSync(command, [...prefix, ...encodeCloudflareOperation(operation)], {
+			cwd: run.cwd ?? options.root,
+			env: {
+				...env,
+				...options.accountId ? { CLOUDFLARE_ACCOUNT_ID: options.accountId } : {},
+				...options.apiBaseUrl ? { CLOUDFLARE_API_BASE_URL: options.apiBaseUrl } : {}
+			},
+			input: run.input,
+			encoding: "utf8",
+			shell: false,
+			windowsHide: true,
+			maxBuffer: 33554432,
+			stdio: streaming ? [
+				"inherit",
+				"inherit",
+				"inherit"
+			] : [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		const raw = {
+			status: result.status ?? 1,
+			stdout: result.stdout ?? "",
+			stderr: result.stderr ?? "",
+			signal: result.signal,
+			error: result.error?.message
+		};
+		if (streaming) return raw;
+		const decoded = decodeCloudflareOperationResult(raw);
+		if (!run.capture) {
+			if (decoded.stdout) process.stdout.write(decoded.stdout);
+			if (decoded.stderr) process.stderr.write(decoded.stderr);
+		}
+		return decoded;
+	};
+}
+//#endregion
+export { detectPreset as a, resolveCloudflareOperationArgv as c, FRAMEWORK_PRESETS as i, resolveProjectCommand as l, decodeCloudflareOperationResult as n, formatProjectCommand as o, encodeCloudflareOperation as r, hasBackendFiles as s, createCloudflareProcessRunner as t };

package/dist/{config-VavjpDnp.d.mts → config-BMHb8RCj.d.mts}

@@ -1,6 +1,7 @@
 import "./types-CKWnYgfy.mjs";
 import { t as VoidAuthProvider } from "./providers-BNKRacMr.mjs";
 import { t as HeadConfig } from "./head-Do8P4puT.mjs";
+import "@void/deploy-core";
 import { RewriteDestination } from "void/routes";
 //#region src/sandbox/config.d.ts
 type SandboxInstanceType = "lite" | "standard-1" | "standard-2" | "standard-3" | "standard-4";

package/dist/config-C_XRIPx2.mjs

@@ -0,0 +1,89 @@
+import { a as join, i as isAbsolute } from "./dist-BVqXeR_h.mjs";
+import { fileURLToPath } from "node:url";
+import { isSandboxRegistryImage } from "@void/deploy-core";
+//#region src/sandbox/config.ts
+const DEFAULT_SANDBOX_BINDING = "SANDBOX";
+const DEFAULT_SANDBOX_CLASS_NAME = "SandboxV1";
+const SANDBOX_MIGRATION_TAG = "void-sandbox-v2";
+function isSandboxEnabled(config) {
+	return config.sandbox !== void 0 && config.sandbox !== false;
+}
+function getDefaultSandboxImage() {
+	return fileURLToPath(new URL("../../sandbox.Dockerfile", import.meta.resolve("void/sandbox")));
+}
+function getDefaultSandboxPlatformImage() {
+	return "cloudflare/debian-trixie";
+}
+function isLocalSandboxImage(image) {
+	const lowerImage = image.toLowerCase();
+	return isAbsolute(image) || image.startsWith("./") || image.startsWith("../") || lowerImage === "dockerfile" || lowerImage.includes("dockerfile") || lowerImage.endsWith("/dockerfile") || lowerImage.endsWith("\\dockerfile");
+}
+function requiresSandboxPlatformImage(config) {
+	if (typeof config.sandbox !== "object" || config.sandbox === null) return false;
+	return typeof config.sandbox.image === "string" && isLocalSandboxImage(config.sandbox.image) && config.sandbox.platformImage === void 0;
+}
+function resolveSandboxConfig(config, root = process.cwd()) {
+	const raw = typeof config.sandbox === "object" ? config.sandbox : {};
+	const image = raw.image ?? getDefaultSandboxImage();
+	const imageBuildContext = raw.imageBuildContext;
+	const platformImage = raw.platformImage ?? (raw.image && !isLocalSandboxImage(raw.image) ? raw.image : getDefaultSandboxPlatformImage());
+	if (!isLocalSandboxImage(image) && !isSandboxRegistryImage(image)) throw new Error("sandbox.image must be a Dockerfile or a digest-pinned Cloudflare registry image (registry.cloudflare.com/<account>/<image>@sha256:<digest>).");
+	if (platformImage !== getDefaultSandboxPlatformImage() && !isSandboxRegistryImage(platformImage)) throw new Error("sandbox.platformImage must be a digest-pinned Cloudflare registry image (registry.cloudflare.com/<account>/<image>@sha256:<digest>).");
+	return {
+		binding: raw.binding ?? "SANDBOX",
+		className: raw.className ?? "SandboxV1",
+		containerName: raw.containerName ?? "void-sandbox-v1",
+		image: resolveSandboxImage(image, root),
+		platformImage,
+		...imageBuildContext && { imageBuildContext: isAbsolute(imageBuildContext) ? imageBuildContext : join(root, imageBuildContext) },
+		...raw.instanceType && { instanceType: raw.instanceType }
+	};
+}
+function resolveSandboxImage(image, root) {
+	if (!isLocalSandboxImage(image) || isAbsolute(image)) return image;
+	return join(root, image);
+}
+function sandboxContainerConfig(sandbox) {
+	return {
+		name: sandbox.containerName,
+		class_name: sandbox.className,
+		scheduling_policy: "durable_object",
+		images: { default: isLocalSandboxImage(sandbox.image) ? {
+			dockerfile: sandbox.image,
+			...sandbox.imageBuildContext && { build_context: sandbox.imageBuildContext }
+		} : { image: sandbox.image } }
+	};
+}
+/** Resolve the final local storage kind without recreating a renamed or deleted class. */
+function resolveSandboxMigrationStorage(migrations, className) {
+	const storage = /* @__PURE__ */ new Map();
+	for (const migration of migrations) {
+		for (const name of migration.new_classes ?? []) storage.set(name, "legacy-kv");
+		for (const name of migration.new_sqlite_classes ?? []) storage.set(name, "sqlite");
+		for (const rename of migration.renamed_classes ?? []) {
+			const sqlite = storage.get(rename.from);
+			storage.delete(rename.from);
+			storage.set(rename.to, sqlite ?? "unknown");
+		}
+		for (const transfer of migration.transferred_classes ?? []) storage.set(transfer.to, "unknown");
+		for (const name of migration.deleted_classes ?? []) storage.delete(name);
+	}
+	return storage.get(className);
+}
+function hasSandboxSqliteMigration(migrations, className) {
+	return resolveSandboxMigrationStorage(migrations, className) === "sqlite";
+}
+/** Refuse namespace reuse before either uploader can change a live Worker. */
+function assertSandboxNamespaceConfig(config, sandbox) {
+	const containers = Array.isArray(config.containers) ? config.containers : [];
+	const durable = config.durable_objects;
+	const binding = durable?.bindings?.find((entry) => entry.name === sandbox.binding);
+	if (binding && (binding.script_name !== void 0 || binding.environment !== void 0)) throw new Error(`sandbox: binding '${sandbox.binding}' must reference the local '${sandbox.className}' class. Choose another sandbox.binding name to preserve the existing external Durable Object.`);
+	const migrations = Array.isArray(config.migrations) ? config.migrations : [];
+	const storage = resolveSandboxMigrationStorage(migrations, sandbox.className);
+	if (storage === "legacy-kv" || storage === "unknown") throw new Error(`sandbox: class '${sandbox.className}' needs SQLite storage, but its existing namespace has ${storage} storage. Preserve the existing migration history and choose a fresh Worker name or a new sandbox.className and sandbox.binding.`);
+	if (storage !== "sqlite" && migrations.some((migration) => migration.tag === "void-sandbox-v2")) throw new Error(`sandbox: migration tag '${SANDBOX_MIGRATION_TAG}' is already configured for another class. Keep the existing history and choose a fresh Worker for Sandbox.`);
+	if (containers.some((container) => container.class_name === sandbox.className && container.scheduling_policy !== "durable_object") || durable?.bindings?.some((binding) => binding.name === sandbox.binding && binding.class_name !== sandbox.className)) throw new Error("Sandbox SDK 1.0 needs a new Durable Object namespace. Back up existing Sandbox data and deploy to a fresh Worker name with the new Sandbox configuration; remove legacy Sandbox bindings, containers, and migrations from that new Worker configuration. See https://developers.cloudflare.com/containers/guides/migrate-to-durable-object-scheduling-policy/.");
+}
+//#endregion
+export { hasSandboxSqliteMigration as a, resolveSandboxConfig as c, assertSandboxNamespaceConfig as i, sandboxContainerConfig as l, DEFAULT_SANDBOX_CLASS_NAME as n, isSandboxEnabled as o, SANDBOX_MIGRATION_TAG as r, requiresSandboxPlatformImage as s, DEFAULT_SANDBOX_BINDING as t };

package/dist/config-entry.d.mts

@@ -1,4 +1,4 @@
-import { t as VoidConfig } from "./config-VavjpDnp.mjs";
+import { t as VoidConfig } from "./config-BMHb8RCj.mjs";
 //#region src/config-entry.d.ts
 /** Define a typed Void project configuration without loading the Vite plugin. */
 export declare function defineConfig<const T extends VoidConfig>(config: T): T;