void 0.10.12 → 0.20.0

package/dist/email-r6DHJyAB.mjs

@@ -0,0 +1,262 @@
+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 };

package/dist/{entry-D7yy4xVH.mjs → entry-DU3oDoQ3.mjs}

@@ -1,5 +1,5 @@
-import { a as join, s as relative } from "./dist-DaKKDf8D.mjs";
-import { n as readProjectPaths } from "./project-paths-BQd7OmIo.mjs";
+import { c as relative, o as join } from "./dist-BrsS7cai.mjs";
+import { n as readProjectPaths } from "./project-paths-SK8nMHPp.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { parseSync } from "vite";
 //#region src/shared/ast.ts

package/dist/env-D4Emu-M_.mjs

@@ -0,0 +1,95 @@
+import { o as join } from "./dist-BrsS7cai.mjs";
+import { n as parseDotenvFile } from "./dotenv-VQxupEUv.mjs";
+import { readdirSync } from "node:fs";
+//#region src/shared/env.ts
+/** Void's single local dotenv file. It is never a production configuration source. */
+const LOCAL_ENV_FILE = ".env";
+/** The fixed browser-exposure convention supported by `void/env`. */
+const CLIENT_ENV_PREFIX = "VITE_";
+function isClientEnvKey(key) {
+	return key.startsWith(CLIENT_ENV_PREFIX);
+}
+/** Read the one local-development dotenv file. */
+function loadLocalEnv(root, options = {}) {
+	return parseDotenvFile(join(root, LOCAL_ENV_FILE), { onWarn: options.onWarn });
+}
+/**
+* Marks the isolated probes and Vite build run by
+* `void deploy --platform cloudflare`.
+*
+* Kept here so the deploy orchestrator and Vite plugin share one spelling.
+* The marker is passed through child-process env only; it is never a Worker
+* binding and is not set for `void dev` or ordinary `vite build` commands.
+*/
+const CLOUDFLARE_DEPLOY_BUILD_ENV = "VOID_CLOUDFLARE_DEPLOY_BUILD";
+/**
+* Find legacy Vite dotenv variants. Void intentionally supports only `.env`;
+* production configuration is project-scoped remote state instead of a file.
+*/
+function findLegacyEnvFiles(root) {
+	try {
+		return readdirSync(root).filter((name) => name.startsWith(".env.") || name === ".env.example" || name === ".dev.vars" || name.startsWith(".dev.vars.")).sort((a, b) => a.localeCompare(b));
+	} catch {
+		return [];
+	}
+}
+/**
+* Resolve whether the plugin should run in "remote" mode (proxy real
+* D1/KV/R2 via the platform) based on the project config plus an optional
+* `VOID_REMOTE` env override.
+*
+* Tri-state override semantics:
+*   - `VOID_REMOTE=1` → force remote mode on
+*   - `VOID_REMOTE=0` → force remote mode off (e.g. local/CI builds of a
+*     project whose `void.json` has `remote: true`)
+*   - unset / any other value → fall back to `config.remote`
+*
+* Both the dev-server plugin (index.ts) and the prerender build plugin
+* (plugin-prerender.ts) must derive `remoteMode` through this helper so
+* dev and build stay in lockstep.
+*/
+function resolveRemoteMode(configRemote) {
+	const override = process.env.VOID_REMOTE;
+	if (override === "1") return true;
+	if (override === "0") return false;
+	return configRemote === true;
+}
+const INTERNAL_ENV_KEY_SET = /* @__PURE__ */ new Set([
+	"__VOID_TOKEN",
+	"__VOID_PROJECT_ID",
+	"__VOID_REMOTE",
+	"__VOID_STAGING",
+	"__VOID_PROXY_URL",
+	"__VOID_PROXY_TOKEN"
+]);
+/**
+* Remove any internal Void env keys from a user-supplied env record. Returns
+* the sanitized record plus the list of keys that were stripped so callers
+* (which live in non-leaf modules) can emit a warning via `voidWarn`.
+*
+* This module is a leaf — it must not import from `../log` or any non-leaf
+* module, otherwise the prerender subprocess's worker bundle acquires
+* unwanted transitive dependencies. That's why warnings are the caller's
+* responsibility.
+*/
+function stripInternalEnvKeys(input) {
+	if (!input) return {
+		sanitized: {},
+		stripped: []
+	};
+	const sanitized = {};
+	const stripped = [];
+	for (const [key, value] of Object.entries(input)) {
+		if (INTERNAL_ENV_KEY_SET.has(key)) {
+			stripped.push(key);
+			continue;
+		}
+		sanitized[key] = value;
+	}
+	return {
+		sanitized,
+		stripped
+	};
+}
+//#endregion
+export { loadLocalEnv as a, isClientEnvKey as i, CLOUDFLARE_DEPLOY_BUILD_ENV as n, resolveRemoteMode as o, findLegacyEnvFiles as r, stripInternalEnvKeys as s, CLIENT_ENV_PREFIX as t };

package/dist/env-DmU2To0C.mjs

@@ -0,0 +1,73 @@
+import { o as join } from "./dist-BrsS7cai.mjs";
+import { D as log, E as intro, O as note, k as outro, r as cliTitle } from "./output-tFQLLj26.mjs";
+import { b as readDeploymentPlatform, c as getToken, x as readProjectConfig } from "./auth-W9WII-mN.mjs";
+import { r as generateEnvTypes, t as findEnvFile } from "./env-types-BNPhro-M.mjs";
+import { c as fetchRemoteSecretNames, l as formatEnvReport, p as validateProdEnv } from "./env-validation-ENpMy6Ez.mjs";
+import { n as PlatformClient } from "./client-CyCHWSO_.mjs";
+import { mkdirSync, writeFileSync } from "node:fs";
+//#region src/cli/env.ts
+async function runEnvCommand(root, args) {
+	console.log();
+	intro(cliTitle(`env ${args.subcommand}`));
+	if (args.subcommand === "check") {
+		await runCheck(root, args.useRemoteSecrets);
+		return;
+	}
+	if (args.subcommand === "types") {
+		runTypes(root);
+		return;
+	}
+}
+async function runCheck(root, useRemoteSecrets) {
+	let remoteSecrets;
+	if (useRemoteSecrets) {
+		const platform = readDeploymentPlatform(root);
+		if (platform === "none") throw new Error("env: Deployment is disabled. Run `void init` to choose a platform.");
+		if (platform === "cloudflare") {
+			const { listCloudflareSecrets, resolveCloudflareOperationContext } = await import("./cloudflare-operations-CPTpRW6d.mjs").then((n) => n.t);
+			remoteSecrets = await listCloudflareSecrets(resolveCloudflareOperationContext(root));
+		} else {
+			const token = getToken(root);
+			if (!token) {
+				log.error("--remote requires authentication. Run `void auth login` first.");
+				process.exit(1);
+			}
+			const config = readProjectConfig(root);
+			if (!config) {
+				log.error("--remote requires a linked project. Run `void project link` first.");
+				process.exit(1);
+			}
+			const client = new PlatformClient(token, { root });
+			remoteSecrets = await fetchRemoteSecretNames(client, config.projectId);
+		}
+	}
+	const { hasSchema, report } = await validateProdEnv(root, {
+		productionOnly: useRemoteSecrets,
+		remoteSecrets
+	});
+	if (!hasSchema) {
+		outro("No env.ts found — nothing to validate.");
+		return;
+	}
+	if (report.valid) {
+		outro(useRemoteSecrets ? "All required remote env names are present; values validate at runtime." : "Local .env values are valid.");
+		return;
+	}
+	note(formatEnvReport(report), "Env validation failed");
+	if (report.missing.length > 0) log.info(useRemoteSecrets ? "Upload missing server values with `void secret put <NAME>`; set VITE_* values in the build shell or schema defaults." : "Add the missing values to .env or set them in your shell.");
+	process.exit(1);
+}
+function runTypes(root) {
+	const envFile = findEnvFile(root);
+	if (!envFile) {
+		outro("No env.ts found at project root — nothing to generate.");
+		return;
+	}
+	const outDir = join(root, ".void");
+	mkdirSync(outDir, { recursive: true });
+	const { dts } = generateEnvTypes(envFile, outDir);
+	writeFileSync(join(outDir, "env.d.ts"), dts);
+	outro(`Wrote ${join(".void", "env.d.ts")}.`);
+}
+//#endregion
+export { runEnvCommand };

package/dist/env-helpers-CyKtOBpj.d.mts

@@ -0,0 +1,22 @@
+import { t as StandardSchemaV1 } from "./standard-schema-Fo_vCAZh.mjs";
+//#region src/runtime/env-helpers.d.ts
+type EnvSchema<T> = StandardSchemaV1<unknown, T> & {
+  optional(): EnvSchema<T | undefined>;
+  default(value: NonNullable<T>): EnvSchema<NonNullable<T>>;
+};
+/** Required string env value. */
+declare function string(): EnvSchema<string>;
+/** Numeric env value. Parses with `Number(raw)`; rejects NaN. */
+declare function number(): EnvSchema<number>;
+/** Boolean env value. Accepts "true"/"false"/"1"/"0" (case-insensitive). */
+declare function boolean(): EnvSchema<boolean>;
+/** URL string — validated via `new URL(raw)`. */
+declare function url(): EnvSchema<string>;
+/** Email string — basic shape validation. */
+declare function email(): EnvSchema<string>;
+/** One of a fixed set of literal string values. */
+declare function oneOf<const Values extends Array<string>>(values: Values): EnvSchema<Values[number]>;
+/** JSON-parsed env value. Specify `T` to type the parsed result. */
+declare function json<T = unknown>(): EnvSchema<T>;
+//#endregion
+export { number as a, url as c, json as i, boolean as n, oneOf as o, email as r, string as s, EnvSchema as t };

package/dist/env-public-D_6u46fX.d.mts

@@ -0,0 +1,135 @@
+import { t as StandardSchemaV1 } from "./standard-schema-Fo_vCAZh.mjs";
+//#region src/runtime/env-public.d.ts
+type AnyValidator = StandardSchemaV1<unknown, unknown>;
+type AnySchema = Record<string, AnyValidator>;
+/**
+ * Type-only stub for the validated env shape. Augmented by the generated
+ * `.void/env.d.ts` so `env.X` is typed per the user's schema. Includes an
+ * index signature so untyped property access returns `unknown` (rather than
+ * a hard error) for bindings and keys not declared in the schema.
+ */
+interface ValidatedEnv {
+  readonly [key: string]: unknown;
+}
+type InferEnv<S extends AnySchema> = { readonly [K in keyof S]: StandardSchemaV1.InferOutput<S[K]>; };
+/**
+ * Register an env schema and return the typed `env` proxy.
+ *
+ * Calling `defineEnv` is the only required step — Void auto-discovers
+ * `env.ts` at project root, imports it, and uses the schema for runtime
+ * validation, type generation, and deploy-time secret checks.
+ *
+ * The return value is identical to the `env` export from `void/env`.
+ * Re-export it from your `env.ts` if you prefer the explicit
+ * `import { env } from "~/env"` pattern.
+ */
+declare function defineEnv<S extends AnySchema>(schema: S): InferEnv<S>;
+/**
+ * Internal: validate the entire schema against the worker's actual env on
+ * the first request per isolate. Catches bad remote-secret values and
+ * post-deploy drift that the deploy CLI can't see (it only knows secret
+ * names, not their values).
+ *
+ * Spliced into the generated worker entry by `compileWorkerEntry`. Cached
+ * after the first call so subsequent requests pay no cost.
+ *
+ * Async lifecycle: this function awaits any async Standard Schema
+ * validators (zod `refine`, arktype async narrows, etc.) and seeds the
+ * per-key cache with the resolved values. Subsequent reads via `env.X`
+ * hit the sync cache — async work only happens here, at boot. If a user
+ * accesses `env.X` for a key with an async validator *before* this
+ * function has run (e.g. during module-top-level code), the proxy will
+ * throw with guidance pointing back to this boot-time pre-validation.
+ */
+declare function _validateEnvOnce(envValues: unknown): Promise<void>;
+/** Internal: framework-only access to the registered schema (for plugin/CLI). */
+declare function _getRegisteredSchema(): AnySchema | null;
+/**
+ * Internal: returns `true` once `defineEnv()` has been called at least once,
+ * regardless of whether the caller passed an empty schema. Gives tooling a
+ * reliable signal — `_getRegisteredSchema()` alone can't distinguish
+ * `defineEnv({})` (an intentional empty schema) from "never called".
+ */
+declare function _hasRegisteredSchema(): boolean;
+/**
+ * Internal: extract `.default(value)` values from the registered schema as
+ * stringified env values. Used for explicit build-time client fallbacks.
+ *
+ * Detection is schema-agnostic: probe each validator with `undefined` and,
+ * if it succeeds with a non-undefined value, that value is the default.
+ * Works for our built-in `.default(...)` helpers and for any Standard
+ * Schema validator with intrinsic default behaviour. Async validators are
+ * skipped (we can't get a sync default).
+ *
+ * Keys with no default — required keys and plain `.optional()` keys — are omitted.
+ */
+declare function _getSchemaDefaults(): Record<string, string>;
+declare class EnvValidationError extends Error {
+  readonly key: string;
+  readonly issues: Array<StandardSchemaV1.Issue>;
+  constructor(key: string, issues: Array<StandardSchemaV1.Issue>);
+}
+/**
+ * Typed env proxy. Reads from the runtime env, validating declared keys
+ * on first access and passing through bindings / unknown keys unchanged.
+ *
+ * Sync-only: the `get` trap must be synchronous, so validators that return
+ * a `Promise` cannot be awaited here. For async Standard Schema validators,
+ * `_validateEnvOnce()` pre-resolves them at worker boot and seeds the
+ * per-env cache; property reads then serve the cached value synchronously.
+ * If an async validator is encountered here without a prior pre-validation,
+ * the trap throws with guidance on how to resolve it.
+ */
+declare const env: ValidatedEnv;
+/** Aggregate report from validating an entire env object against the schema. */
+type EnvValidationReport = {
+  valid: boolean;
+  missing: Array<string>;
+  invalid: Array<{
+    key: string;
+    messages: Array<string>;
+  }>;
+  /**
+   * Resolved values for keys that validated successfully. Used to seed the
+   * per-env cache after async pre-validation so sync `env.X` reads hit the
+   * cache.
+   */
+  values: Map<string, unknown>;
+};
+/**
+ * Validate an env record (local dotenv, build inputs, or runtime bindings) against
+ * the registered schema. Used by the dev plugin (warnings), the deploy CLI
+ * (hard error), and `_validateEnvOnce` at worker boot.
+ *
+ * Async: awaits any validators that return a `Promise` (zod async refines,
+ * arktype narrows, etc.). Callers already run in async contexts.
+ */
+declare function validateAllEnv(envValues: Record<string, unknown>): Promise<EnvValidationReport>;
+declare global {
+  namespace Cloudflare {
+    interface Env {
+      DB: D1Database;
+      KV: KVNamespace;
+      STORAGE: R2Bucket;
+      AI: Ai;
+      SANDBOX: DurableObjectNamespace<import("@cloudflare/sandbox").Sandbox>;
+      /** @internal Service binding to proxy worker (AI, revalidation, future features) */
+      __VOID_PROXY?: Fetcher;
+      /** @internal Custom proxy URL override */
+      __VOID_PROXY_URL?: string;
+      /** @internal Auth token for HTTP proxy (local dev) */
+      __VOID_TOKEN?: string;
+      /** @internal Project ID for HTTP proxy (local dev) */
+      __VOID_PROJECT_ID?: string;
+      /** @internal Staging environment flag */
+      __VOID_STAGING?: string;
+      /** @internal Project ID (service binding path) */
+      __PROJECT_ID?: string;
+      /** @internal Proxy token (service binding path) */
+      __VOID_PROXY_TOKEN?: string;
+      [key: `QUEUE_${string}`]: Queue<unknown> | undefined;
+    }
+  }
+}
+//#endregion
+export { _getSchemaDefaults as a, defineEnv as c, _getRegisteredSchema as i, env as l, EnvValidationReport as n, _hasRegisteredSchema as o, ValidatedEnv as r, _validateEnvOnce as s, EnvValidationError as t, validateAllEnv as u };

package/dist/{env-types-QBj-ndax.mjs → env-types-BNPhro-M.mjs}

@@ -1,5 +1,5 @@
-import { s as relative } from "./dist-DaKKDf8D.mjs";
-import { n as readProjectPaths } from "./project-paths-BQd7OmIo.mjs";
+import { c as relative } from "./dist-BrsS7cai.mjs";
+import { n as readProjectPaths } from "./project-paths-SK8nMHPp.mjs";
 import { i as voidWarn } from "./log-ChfPKsVd.mjs";
 import { existsSync } from "node:fs";
 //#region src/codegen/env-types.ts