void 0.20.0 → 0.20.1

package/dist/sqlite-validation-BzKMWnO4.mjs

@@ -0,0 +1,25 @@
+//#region src/migrations/sqlite-validation.ts
+var SqliteMigrationError = class extends Error {
+	constructor(name, cause) {
+		super(`Migration ${name} could not be applied to a fresh SQLite database: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+		this.name = "SqliteMigrationError";
+	}
+};
+/** Replay migration history without touching an application's database. Caller owns the result. */
+async function openMigrationValidationDatabase(migrations) {
+	const { DatabaseSync } = await import("node:sqlite");
+	const db = new DatabaseSync(":memory:", { enableDoubleQuotedStringLiterals: false });
+	try {
+		for (const migration of migrations) try {
+			db.exec(migration.sql);
+		} catch (cause) {
+			throw new SqliteMigrationError(migration.name, cause);
+		}
+		return db;
+	} catch (error) {
+		db.close();
+		throw error;
+	}
+}
+//#endregion
+export { openMigrationValidationDatabase as n, SqliteMigrationError as t };

package/dist/{validate-Bihr8WBi.mjs → validate-tBBN_dXH.mjs}

@@ -365,6 +365,7 @@ function hasTopLevelKeyword(statement, keyword) {
 	return false;
 }
 function hasUnboundedWrite(statement) {
+	if (/^(?:CREATE\s+(?:(?:TEMP|TEMPORARY|UNLOGGED)\s+)?|ALTER\s+)TABLE\b/i.test(statement)) return false;
 	if (/\bDELETE\s+FROM\b/i.test(statement)) return !hasTopLevelKeyword(statement, "WHERE");
 	if (/\bUPDATE\b[\s\S]*\bSET\b/i.test(statement)) return !hasTopLevelKeyword(statement, "WHERE");
 	return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "void",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/voidzero-dev/void.git",
@@ -313,11 +313,11 @@
     "@cloudflare/vite-plugin": "1.54.7",
     "@cloudflare/workers-types": "^4.20260702.1",
     "@napi-rs/keyring": "2.0.0",
-    "@void/deploy-cloudflare": "0.20.0",
-    "@void/deploy-core": "0.20.0",
-    "@void/edge": "0.20.0",
-    "@void/isr": "0.20.0",
-    "@void/platform": "0.20.0",
+    "@void/deploy-cloudflare": "0.20.1",
+    "@void/deploy-core": "0.20.1",
+    "@void/edge": "0.20.1",
+    "@void/isr": "0.20.1",
+    "@void/platform": "0.20.1",
     "better-auth": "^1.7.3",
     "better-sqlite3": "^13.0.3",
     "blake3-jit": "^1.1.0",
@@ -363,7 +363,7 @@
     "zod": "^4.6.1"
   },
   "peerDependencies": {
-    "@void/md": "0.20.0",
+    "@void/md": "0.20.1",
     "arktype": ">=2.0.0",
     "valibot": ">=1.0.0-beta.7",
     "vite": "^8.0.0",

package/skills/void/docs/guide/email.md

@@ -66,9 +66,40 @@ The project owner's email (the GitHub address you signed up with) is added autom
 ::: warning When this is the right fit
 The shared sender is great for: ops alerts to the team, notifications to the project owner, reply-by-email flows on top of inbound, internal/app-internal mail.
 
-For SaaS sending to arbitrary end-users (every signup gets a welcome email), the per-recipient verification model doesn't fit. On [your own Cloudflare account](#your-own-cloudflare-account) with Workers Paid, Void onboards your mail domain for Email Sending, which lifts the verified-recipient gate. Otherwise use [Resend](https://resend.com), [Postmark](https://postmarkapp.com), or [SES](https://aws.amazon.com/ses/) directly — install their SDK and call it from your handler. We may formalize this with a provider abstraction later if there is demand; until then, calling the SDK directly is simple enough that the wrapper would not earn its keep.
+For SaaS sending to arbitrary end-users (every signup gets a welcome email), the per-recipient verification model doesn't fit. On the platform, [registering your own domain](#your-own-domain-on-the-platform) lifts that gate for sends from that domain. On [your own Cloudflare account](#your-own-cloudflare-account) with Workers Paid, Void onboards your mail domain for Email Sending, which lifts the verified-recipient gate. Otherwise use [Resend](https://resend.com), [Postmark](https://postmarkapp.com), or [SES](https://aws.amazon.com/ses/) directly — install their SDK and call it from your handler. We may formalize this with a provider abstraction later if there is demand; until then, calling the SDK directly is simple enough that the wrapper would not earn its keep.
 :::
 
+## Your own domain on the platform
+
+The shared sender lives on the platform's `mail.void.cloud` zone. To send — and receive — at a domain you own, register its Cloudflare zone with the project:
+
+```sh
+void email domain add acme.com
+```
+
+`add` needs one credential for the zone and offers two ways to grant it. The default opens Cloudflare's hosted consent page for an OAuth grant — one Allow click; the page names Wrangler, whose OAuth client Void borrows for it. Pressing Enter at any point, or any failure of the consent flow, switches to the fallback: a three-click template link that creates a scoped API token, which the CLI watches for on the clipboard or takes as a masked paste. Either credential is POSTed to the platform once and stored there, encrypted for the project — nothing is kept on your machine.
+
+**Where the mail lives.** Void never enables routing over live mail: when `acme.com` already carries MX records, the CLI proposes `mail.acme.com` (`[change with --subdomain]`); the apex is used only when it carries no MX records. `--subdomain <label|host>` overrides the proposal outright.
+
+**The pending state.** Enabling Email Routing on a subdomain is the one step with no API path, so when it is the step that remains, `add` prints it — Cloudflare dashboard → Email Routing → acme.com → Settings → Subdomains → add the subdomain — and the row sits at `pending`. Poll with:
+
+```sh
+void email domain status acme.com
+```
+
+Once public MX on the domain names Cloudflare, the row flips itself to `active` — no second command. `status` also re-probes the stored credential and the relay worker on every call, so it doubles as the drift report.
+
+**When a row is not active.** `failed` names the step that failed; fix it and re-run `void email domain add acme.com` — adding again replaces the credential and retries, and the routing rules stay. `token_revoked` / `token_expired` mean the stored credential died at Cloudflare; re-run `add` with a fresh grant or token — rules and the relay stay.
+
+Two upkeep verbs:
+
+- `void email domain sync acme.com` redeploys the relay at the current version and rotates its secret — the answer when `status` reports the relay missing or drifted.
+- `void email domain remove acme.com` deletes the platform row, the stored credential, and the relay secret. Cloudflare-side cleanup is best-effort; anything that could not be finished is named so you can delete it by hand.
+
+Two rules bound registrations: one live email domain per Cloudflare zone (a second `add` on the same zone is refused until you `remove` the first), and one project per domain (a domain registered to another project is refused).
+
+Sends from a registered domain skip the verified-recipient allowlist — the domain's own Email Sending onboarding replaces it — while platform quota and abuse controls still apply. Inbound needs nothing further: once the domain is `active`, mail to any address on it reaches your `email/` handlers.
+
 ## Options
 
 | Option        | Type                         | Notes                                                            |
@@ -87,7 +118,7 @@ At most 100 recipients across `to`, `cc` and `bcc` per call. Each address is che
 
 `Address` accepts either a string (`"hello@acme.dev"` or `"Name <hello@acme.dev>"`) or an object (`{ email, name? }`). Display names with non-ASCII characters are RFC 2047 encoded automatically.
 
-On the platform the sender is pinned to your project. `from` must be your project's own platform address — `<project-slug>@mail.void.cloud` or `<project-slug>+<tag>@mail.void.cloud`, optionally with a display name (`Acme <acme+noreply@mail.void.cloud>`). Anything else is rejected with `INVALID_FROM`. Omit `from` and Void fills in `<project-slug>+noreply@mail.void.cloud` for you. Sending from your own domain on the platform is not supported yet.
+On the platform the sender is pinned to your project. `from` must be your project's own platform address — `<project-slug>@mail.void.cloud` or `<project-slug>+<tag>@mail.void.cloud`, optionally with a display name (`Acme <acme+noreply@mail.void.cloud>`) — or any address on a domain registered with `void email domain add` (see [Your own domain on the platform](#your-own-domain-on-the-platform)). Anything else is rejected with `INVALID_FROM`. Omit `from` and Void fills in `<project-slug>+noreply@mail.void.cloud` for you.
 
 On your own Cloudflare account, `from` defaults to `email.from` from `void.json` and must be on a domain your account can send from; Cloudflare rejects any other sender and `sendEmail` reports it as `INVALID_FROM`.
 
@@ -383,7 +414,7 @@ never throws, while `replyEmail` throws when it cannot determine a sender.
 
 ### Configuring inbound delivery
 
-In production, inbound runs on one shared mail facility. The platform routes `<slug>+anything@<mail domain>` to your worker's `email()` export — **there is nothing to configure in the Cloudflare dashboard and no per-project DNS work**. Your handlers are live as soon as the deploy lands.
+In production, inbound runs on one shared mail facility. The platform routes `<slug>+anything@<mail domain>` to your worker's `email()` export — **there is nothing to configure in the Cloudflare dashboard and no per-project DNS work**. Your handlers are live as soon as the deploy lands. A [registered custom domain](#your-own-domain-on-the-platform) lands on the same facility: once `void email domain add` reports it `active`, mail to any address on the domain reaches your `email/` handlers, with nothing further to configure.
 
 On your own Cloudflare account there is no shared facility: the deploy derives one Email Routing rule per handler and writes it into `wrangler.jsonc` for you — see [Your own Cloudflare account](#your-own-cloudflare-account).
 

package/skills/void/docs/guide/platform-development.md

@@ -232,4 +232,33 @@ Publishing requires both SDK CI and platform CI, including the platform unit and
 API integration suites. Release tags also run the Windows SDK checks; a passing
 SDK-only build cannot publish a changed control plane.
 
+### Retrying a Release
+
+To retry a failed release without moving an existing tag, add `+retry.N` to a
+new Git tag, with `N` starting at `1`. Keep the package versions unchanged:
+
+| Git tag                  | Package version | npm channel |
+| ------------------------ | --------------- | ----------- |
+| `v0.21.0`                | `0.21.0`        | `latest`    |
+| `v0.21.0+retry.1`        | `0.21.0`        | `latest`    |
+| `v0.21.0-beta.1+retry.2` | `0.21.0-beta.1` | `beta`      |
+
+For example, when the packages are at `0.21.0`, commit the release fix and tag
+that commit:
+
+```sh
+git tag -a 'v0.21.0+retry.1' -m 'Retry 0.21.0 publication.'
+git push origin 'refs/tags/v0.21.0+retry.1'
+```
+
+The retry suffix belongs only in the Git tag, not in `package.json`. A `-1`
+suffix is a distinct prerelease version, not a retry. Tag and package versions
+are checked before dependency installation and the full CI jobs; retries still
+run the normal release checks.
+
+Retries publish only package versions that are still missing from npm. They
+cannot replace an already-published version. If an earlier attempt partially
+published the release and you changed its package contents, bump the version
+instead of combining different contents under the same version.
+
 For implementation history, use the design archive at `platform/meta/design-docs/README.md`. Its proposals explain earlier decisions; the source and current guides define the supported behavior.

package/skills/void/docs/reference/cli.md

@@ -46,6 +46,7 @@ Use this page as a command reference. If you are setting up a project for the fi
 | `void email destinations`         | List verified recipient addresses                                             |
 | `void email allow <address>`      | Add a recipient and send a verification email                                 |
 | `void email disallow <address>`   | Remove a recipient from the allowlist                                         |
+| `void email domain`               | Send and receive at your own domain on a Cloudflare zone                      |
 | `void init`                       | Setup wizard for new or existing projects                                     |
 
 ## Binary Invocation
@@ -742,6 +743,8 @@ Generate SQL migration files from schema changes.
 
 The command compares your current `db/schema.ts` or `db/schema/` modules against the last generated Drizzle snapshot and writes new migration artifacts under `db/migrations/`. When Void-managed auth is enabled, it also resolves the Better Auth schema in production mode and includes those tables automatically, including configured renames and plugin tables. This works for auth-only apps without an application schema. Review and commit the generated files before deploying.
 
+For SQLite, Void checks that the migration history applies to a fresh database. If generation fails this check, the previous SQL, snapshots, and journal are restored. If an existing migration fails, repair that unapplied migration first: rerunning generation compares snapshots and does not repair existing SQL. This check does not verify that a migration preserves existing data; review table rebuilds and foreign-key actions carefully.
+
 ### `void db status`
 
 Show migration status. Displays which migrations are applied or pending locally, then uses the saved deployment target for remote status: the hosted API for Void projects, the pinned D1 database and its configured migration table for direct Cloudflare SQLite projects, or the shell `DATABASE_URL` for direct Cloudflare PostgreSQL/MySQL projects. If the remote credential or service is unavailable, local status is still shown.
@@ -1319,6 +1322,54 @@ void email disallow <address> [--project <name>]
 
 Remove one recipient from the project's destination list. Sends to that address are refused within about a minute: the platform updates the project's allowlist as part of the command, and the proxy re-reads it every 60 seconds. No deploy is involved.
 
+### `void email domain`
+
+```
+void email domain <add|status|list|sync|remove> [<domain>] [--project <name>]
+```
+
+Send and receive at your own domain on a Cloudflare zone you own, registered to the project. Void platform only — on your own Cloudflare account the mail domain comes from `email.from` instead (see `void email setup`). The walkthrough is [Your own domain on the platform](../guide/email.md#your-own-domain-on-the-platform).
+
+#### `void email domain add`
+
+```
+void email domain add <domain> [--subdomain <label|host>] [--project <name>]
+```
+
+Register the domain with the project. One credential is required, granted two ways: an OAuth grant from Cloudflare's hosted consent page (the page names Wrangler — Void borrows its OAuth client), or, as the fallback Enter switches to at any point, a scoped API token created from a three-click template link and picked up from the clipboard or a masked paste. The credential is POSTed once and stored on the platform, encrypted for the project — nothing is kept locally. Needs an interactive terminal. The CLI proposes `mail.<domain>` when the apex already carries MX records and allows the apex only when it carries none; `--subdomain` overrides the proposal. One live email domain per zone and one project per domain are enforced — a conflict is refused with a 409. Re-running `add` on a `failed`, `token_revoked`, or `token_expired` row replaces the credential and retries; the routing rules stay.
+
+#### `void email domain status`
+
+```
+void email domain status <domain> [--project <name>]
+```
+
+Show one registered domain. The platform re-probes the stored credential and the relay worker on every call, so this doubles as the drift report. A `pending` row whose only remaining step is the dashboard's subdomain form (printed by `add`) self-clears to `active` once public MX on the domain names Cloudflare — which makes this command the poll for that one human step.
+
+#### `void email domain list`
+
+```
+void email domain list [--project <name>]
+```
+
+List the project's registered email domains with their status and mode.
+
+#### `void email domain sync`
+
+```
+void email domain sync <domain> [--project <name>]
+```
+
+Redeploy the domain's relay worker at the current version and rotate its secret — the fix when `status` reports the relay missing or drifted.
+
+#### `void email domain remove`
+
+```
+void email domain remove <domain> [--project <name>]
+```
+
+Delete the registration: the platform row, the stored credential, and the relay secret. Cloudflare-side cleanup is best-effort; any step that fails is named (`failed_steps`) so you can finish it in the Cloudflare dashboard.
+
 ### `void email status`
 
 ```

package/dist/email-r6DHJyAB.mjs

@@ -1,262 +0,0 @@
-import { D as log, F as isCancel, O as note, c as import_picocolors, w as confirm } from "./output-tFQLLj26.mjs";
-import { C as renderAddressMap, S as preflightEmail, a as isWranglerNonInteractiveOrCI, b as createNodeEmailDns, i as discoverRootWranglerConfig, o as loadProvisionModule, r as deriveWorkerName, s as resolveDeployTransport, t as createDeployWranglerRunner, u as runWranglerAuthToken, w as renderEmailChecklist, x as findEmailConfigConflicts, y as applyEmailSetup } from "./deploy-CcDoeBIf.mjs";
-import { n as readProjectPaths } from "./project-paths-SK8nMHPp.mjs";
-import { c as getToken, x as readProjectConfig } from "./auth-W9WII-mN.mjs";
-import { k as writeProvisionedWranglerConfig } from "./wrangler--imS8n0d.mjs";
-import { f as readConfig } from "./config-BQFq7QvD.mjs";
-import { a as scanEmailHandlersSync } from "./email-Ce6SQq-i.mjs";
-import { n as PlatformClient } from "./client-CyCHWSO_.mjs";
-import { parseRootWranglerConfig, readWranglerTopLevelString } from "@void/deploy-cloudflare";
-//#region src/cli/email.ts
-async function runEmailCommand(root, args) {
-	if (args.platform === "cloudflare") return runEmailCloudflareCommand(root, args);
-	if (args.subcommand === "setup") {
-		log.error("email: `void email setup` sets email up on your OWN Cloudflare account — run it with `--platform cloudflare`. The Void platform needs no setup: deploy, and `void email usage` shows your address.");
-		process.exit(1);
-	}
-	if (args.subcommand === "status") {
-		log.error("email: `void email status` is available with `--platform cloudflare` today. On the Void platform use `void email usage` and `void email destinations`.");
-		process.exit(1);
-	}
-	const token = getToken(root);
-	if (!token) {
-		log.error("Not logged in. Run `void auth login` first.");
-		process.exit(1);
-	}
-	const client = new PlatformClient(token, { root });
-	const requestedSlug = args.projectSlug ?? process.env.VOID_PROJECT?.trim();
-	let projectId;
-	if (requestedSlug) {
-		const project = (await client.listProjects()).find((p) => p.slug === requestedSlug);
-		if (!project) {
-			log.error(`project: No project found with slug '${requestedSlug}'.`);
-			process.exit(1);
-		}
-		projectId = project.id;
-	} else {
-		const config = readProjectConfig(root);
-		if (!config) {
-			log.error("No linked project. Run `void project link` or pass --project <name>.");
-			process.exit(1);
-		}
-		projectId = config.projectId;
-	}
-	switch (args.subcommand) {
-		case "usage": return emailUsage(client, projectId);
-		case "logs": return emailLogs(client, projectId, args.limit);
-		case "destinations": return emailDestinations(client, projectId);
-		case "allow": return emailAllow(client, projectId, args.address);
-		case "disallow": return emailDisallow(client, projectId, args.address);
-	}
-}
-async function emailUsage(client, projectId) {
-	const usage = await client.getEmailUsage(projectId);
-	const status = usage.suspended ? import_picocolors.default.red("SUSPENDED") : import_picocolors.default.green("active");
-	const lines = [
-		`Month:       ${usage.month}`,
-		`Status:      ${status}`,
-		`Outbound:    ${usage.sent} / ${usage.limit} (${usage.remaining} remaining)`,
-		`Inbound:     ${usage.received}`
-	];
-	note(lines.join("\n"), "Email Usage");
-}
-async function emailDestinations(client, projectId) {
-	const rows = await client.listEmailDestinations(projectId);
-	if (rows.length === 0) {
-		log.info("No verified destinations. Run `void email allow <address>` to add one — Cloudflare will email the recipient with a verification link.");
-		return;
-	}
-	const lines = rows.map((d) => {
-		const status = d.status === "verified" ? import_picocolors.default.green("verified") : d.status === "pending" ? import_picocolors.default.yellow("pending") : import_picocolors.default.red("failed");
-		return `  ${d.address.padEnd(40)} ${status}`;
-	});
-	note(lines.join("\n"), "Email Destinations");
-}
-/**
-* `void email allow <address>` — exported for the unit test; the command
-* entry (`runEmailCommand`) resolves the client and project first.
-*/
-async function emailAllow(client, projectId, address) {
-	const dest = await client.addEmailDestination(projectId, address);
-	const sent = dest.verificationSent !== false && (dest.created || dest.platformVerificationPending);
-	if (dest.status === "verified") log.success(`${dest.address} is already verified.`);
-	else if (sent) {
-		log.success(`Verification email sent to ${dest.address}.`);
-		log.info("They click the link in their inbox — no Void or Cloudflare account needed. `void email destinations` to poll status.");
-	} else if (dest.created) log.warn(`${dest.address} is on this project's list now, but Cloudflare already had the address pending (added by another project, or by hand), so no new verification email was sent — the link it mailed when the address was first added is the one to click. ${freshLinkHint(dest.address)}`);
-	else log.info(`${dest.address} is still pending — Cloudflare emailed them a verification link when the address was first added, and a repeat add sends nothing new. ${freshLinkHint(dest.address)}`);
-}
-/**
-* Cloudflare has no API to resend its verification mail; the only fresh link
-* is a fresh registration, and the platform deletes the Cloudflare-side
-* address only once no project still lists it.
-*/
-function freshLinkHint(address) {
-	return `For a fresh link, remove the address from every project that lists it (\`void email disallow ${address}\`), then \`void email allow ${address}\` — Cloudflare mails a new link only when it registers the address anew.`;
-}
-/**
-* `void email disallow <address>` — exported for the unit test; the command
-* entry (`runEmailCommand`) resolves the client and project first.
-*
-* No deploy is involved: the api tightens the proxy's `email-allowlist`
-* KV mirror inside the DELETE (and answers 503 if that write fails), and
-* the proxy re-reads the mirror with a 60s `cacheTtl` on both the send
-* path and inbound forward/reply — so the address is refused once that
-* per-colo cache turns over.
-*/
-async function emailDisallow(client, projectId, address) {
-	const dest = (await client.listEmailDestinations(projectId)).find((d) => d.address.toLowerCase() === address.toLowerCase());
-	if (!dest) {
-		log.error(`destination: '${address}' is not in the project's allowlist.`);
-		process.exit(1);
-	}
-	await client.removeEmailDestination(projectId, dest.id);
-	log.success(`Removed ${dest.address}. Sends to it are refused within about a minute.`);
-}
-/**
-* `void email logs` — exported for the unit test; the command entry
-* (`runEmailCommand`) resolves the client and project first.
-*/
-async function emailLogs(client, projectId, limit) {
-	const result = await client.getEmailLogs(projectId, limit);
-	if (result.pending) {
-		log.info(result.note ?? "Persistent log storage is not yet wired up.");
-		log.info("Email activity logs are not available yet. Console output from your email handler appears in `void project logs`.");
-		return;
-	}
-	if (result.logs.length === 0) {
-		log.info("No email activity recorded.");
-		return;
-	}
-	const lines = result.logs.map((entry) => {
-		const ts = new Date(entry.timestamp).toISOString();
-		const dir = entry.direction === "sent" ? "→" : "←";
-		const subject = entry.subject ? ` "${entry.subject}"` : "";
-		return `${ts}  ${dir}  ${entry.from} → ${entry.to}  ${entry.status}${subject}`;
-	});
-	note(lines.join("\n"), "Email Logs");
-}
-/**
-* `void email setup --platform cloudflare` and `void email status --platform cloudflare`.
-*
-* `setup` is the deploy's step 3b-ii on its own: preflight → checklist → the one Enter →
-* apply → write the root wrangler.jsonc. It exists for CI: a non-interactive deploy that
-* finds email not ready prints the checklist and says to run this once, commit
-* wrangler.jsonc, and redeploy. Rules and the catch-all stay wrangler's job — the next
-* `void deploy --platform cloudflare` applies the plan from the written `addresses`. It
-* is also the ONLY place a sending onboarding the committed binding remembers as refused
-* (Workers Free) is retried — on its own prompt, after a Workers Paid upgrade; the deploy
-* reads that row as settled and never retries it.
-*
-* `status` is the preflight alone, printed, exit 1 when not ready.
-*/
-async function runEmailCloudflareCommand(root, args, deps = {}) {
-	const exit = deps.exit ?? ((code) => process.exit(code));
-	const print = deps.print ?? ((block) => log.message(block));
-	const fail = (message) => {
-		log.error(message);
-		return exit(1);
-	};
-	const from = readConfig(root).email?.from;
-	if (!from) return fail("email: no sender configured. Add \"email\": { \"from\": \"you@mail.acme.com\" } to void.json — its host is the domain email is set up on.");
-	const paths = readProjectPaths(root);
-	const handlers = scanEmailHandlersSync(paths.sourceRoot);
-	const configPath = discoverRootWranglerConfig(root);
-	const rootConfig = parseRootWranglerConfig(configPath);
-	await loadProvisionModule();
-	let apiBaseUrl;
-	try {
-		apiBaseUrl = resolveDeployTransport(root, rootConfig);
-	} catch (err) {
-		return fail(`email: ${err instanceof Error ? err.message : String(err)}`);
-	}
-	const accountId = readWranglerTopLevelString(rootConfig, "account_id") ?? (process.env.CLOUDFLARE_ACCOUNT_ID?.trim() || void 0);
-	if (!accountId) return fail([
-		"email: no Cloudflare account is pinned.",
-		"Set `account_id` in your root wrangler.jsonc, or export CLOUDFLARE_ACCOUNT_ID —",
-		"the same pin `void deploy --platform cloudflare` needs."
-	].join("\n"));
-	const workerName = readWranglerTopLevelString(rootConfig, "name") ?? deriveWorkerName(root);
-	const runWrangler = deps.runWrangler ?? createDeployWranglerRunner(root, accountId, apiBaseUrl);
-	const getSessionBearer = deps.getSessionBearer ?? (() => runWranglerAuthToken(runWrangler, configPath));
-	const sendEmail = rootConfig.send_email;
-	const inputs = {
-		handlers,
-		from,
-		workerName,
-		accountId,
-		existingSendEmail: Array.isArray(sendEmail) ? sendEmail : null,
-		existingAddresses: rootConfig.addresses,
-		existingVars: rootConfig.vars && typeof rootConfig.vars === "object" && !Array.isArray(rootConfig.vars) ? rootConfig.vars : null,
-		configConflicts: findEmailConfigConflicts(rootConfig),
-		wranglerArgs: [
-			"-c",
-			configPath,
-			"--env="
-		],
-		apiBaseUrl,
-		runWrangler,
-		getSessionBearer,
-		fetchImpl: deps.fetchImpl ?? fetch,
-		dns: deps.dns ?? await createNodeEmailDns()
-	};
-	let pre;
-	try {
-		pre = await preflightEmail(inputs);
-	} catch (err) {
-		return fail(`email: ${err instanceof Error ? err.message : String(err)}`);
-	}
-	print(renderEmailChecklist(pre));
-	if (args.subcommand === "status") {
-		print(renderAddressMap({
-			from,
-			routes: pre.derived.routes,
-			addresses: pre.rules.mine,
-			sendingReady: pre.sending.state === "ready",
-			pendingLabel: "(no rule yet)"
-		}));
-		if (pre.ready) {
-			log.success(`Email is set up on ${pre.domain}.`);
-			return;
-		}
-		log.warn(`Email is not set up on ${pre.domain} yet — run \`void email setup --platform cloudflare\`.`);
-		return exit(1);
-	}
-	if (pre.blockers.some((b) => b.scope === "all")) return fail("email: nothing was changed — fix the ✘ rows above and rerun.");
-	if (!pre.ready || pre.sendingRetryable) {
-		if (!(deps.isInteractive ?? !isWranglerNonInteractiveOrCI())) return fail("email: `void email setup` changes your Cloudflare account, so it needs an interactive terminal. Run it locally once, commit wrangler.jsonc, then redeploy.");
-		if (!await (deps.confirm ?? (async (message) => {
-			const answer = await confirm({
-				message,
-				initialValue: true
-			});
-			return !isCancel(answer) && answer === true;
-		}))(pre.ready ? `Onboard ${pre.domain} for Email Sending? Inbound already works; onboarding needs Workers Paid.` : `Set up email on ${pre.domain}?`)) {
-			log.info("Nothing changed.");
-			return;
-		}
-	}
-	const out = await applyEmailSetup(pre, inputs);
-	if (out.lines.length > 0) print(out.lines.join("\n"));
-	try {
-		writeProvisionedWranglerConfig(root, out.patch, { configPath });
-	} catch (err) {
-		return fail(`email: could not update ${configPath} — ${err instanceof Error ? err.message : String(err)}`);
-	}
-	print(renderAddressMap({
-		from,
-		routes: pre.derived.routes,
-		addresses: out.patch.addresses ?? [],
-		sendingReady: out.sendingReady,
-		pendingLabel: "(no rule yet)"
-	}));
-	if (!out.inboundReady) {
-		const missing = !out.routingReady ? `Email Routing on ${pre.domain} is not ready` : !out.subaddressingReady ? `subaddressing on ${pre.apex} is still off (support+anything@ would not reach support@)` : "`addresses` was withheld";
-		log.warn(`Email is not set up on ${pre.domain} yet — ${missing}; no routing rule is created until it is. Finish the step above, then rerun \`void email setup --platform cloudflare\`.`);
-		return exit(1);
-	}
-	if ((out.patch.addresses ?? []).length > 0) log.info("Routing rules are created by the next `void deploy --platform cloudflare`, which applies the Email Routing plan from `addresses`.");
-	log.success(`Email set up on ${pre.domain}.`);
-}
-//#endregion
-export { runEmailCommand };