void 0.10.13 → 0.20.1

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-BcQzYgoG.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-Clirrol3.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-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-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