void 0.1.6 → 0.7.0

package/dist/runtime/better-auth.mjs

@@ -0,0 +1,33 @@
+import { n as applySqliteAuthMigrations } from "../auth-migrations-BAtAck2g.mjs";
+import { t as createVoidAuthRuntime } from "../better-auth-shared-CdYmQGry.mjs";
+//#region src/runtime/better-auth.ts
+async function resolveDatabase(env) {
+	if (!env.DB) throw new Error("auth: Better Auth requires the \"DB\" D1 binding for sqlite apps.");
+	return {
+		database: env.DB,
+		async dispose() {}
+	};
+}
+async function runSqliteAuthMigrations(_request, env, runtime, migrationSchema) {
+	if (!migrationSchema) throw new Error("auth: Migration schema is unavailable.");
+	if (runtime.dialect !== "sqlite") throw new Error(`auth: Runtime mismatch. Expected sqlite, received '${runtime.dialect}'.`);
+	if (migrationSchema.dialect !== "sqlite") throw new Error(`auth: Runtime mismatch. Expected sqlite, received '${migrationSchema.dialect}'.`);
+	if (!env.DB) throw new Error("auth: Better Auth requires the \"DB\" D1 binding for sqlite apps.");
+	await applySqliteAuthMigrations({
+		async all(sql) {
+			return (await env.DB.prepare(sql).all()).results ?? [];
+		},
+		async run(sql) {
+			await env.DB.prepare(sql).run();
+		}
+	}, migrationSchema);
+}
+const runtime = createVoidAuthRuntime("sqlite", resolveDatabase, runSqliteAuthMigrations);
+const resolveVoidAuthOptions = runtime.resolveVoidAuthOptions;
+const createVoidAuth = runtime.createVoidAuth;
+const resolveVoidAuthState = runtime.resolveVoidAuthState;
+const runVoidAuthMiddleware = runtime.runVoidAuthMiddleware;
+const handleVoidAuthRequest = runtime.handleVoidAuthRequest;
+const runVoidAuthMigrations = runtime.runVoidAuthMigrations;
+//#endregion
+export { createVoidAuth, handleVoidAuthRequest, resolveVoidAuthOptions, resolveVoidAuthState, runVoidAuthMiddleware, runVoidAuthMigrations };

package/dist/runtime/client.d.mts

@@ -0,0 +1,6 @@
+import { n as AuthState, r as AuthUser, t as AuthSession } from "../auth-BdsJ0Aff.mjs";
+import { auth, createAuthClient } from "./auth-client.mjs";
+import { t as FetchError } from "../fetch-error-CVZ5CGA-.mjs";
+import { fetch } from "./fetch.mjs";
+import { fetchStream } from "./fetch-stream.mjs";
+export { type AuthSession, type AuthState, type AuthUser, FetchError, FetchError as StreamError, auth, createAuthClient, fetch, fetchStream };

package/dist/runtime/client.mjs

@@ -0,0 +1,5 @@
+import { t as FetchError } from "../fetch-error-BQ8sZ5Nd.mjs";
+import { fetch } from "./fetch.mjs";
+import { fetchStream } from "./fetch-stream.mjs";
+import { auth, createAuthClient } from "./auth-client.mjs";
+export { FetchError, FetchError as StreamError, auth, createAuthClient, fetch, fetchStream };

package/dist/runtime/db-pg.d.mts

@@ -0,0 +1,2 @@
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+export { type NodePgDatabase };

package/dist/runtime/db-pg.mjs

@@ -0,0 +1 @@
+export {};

package/dist/runtime/db.d.mts

@@ -0,0 +1,17 @@
+import { DrizzleD1Database, DrizzleD1Database as DrizzleD1Database$1 } from "drizzle-orm/d1";
+import { and, asc, avg, between, count, desc, eq, exists, gt, gte, ilike, inArray, isNotNull, isNull, like, lt, lte, max, min, ne, not, notBetween, notExists, notInArray, notLike, or, sql, sum } from "drizzle-orm";
+
+//#region src/runtime/db.d.ts
+/**
+* Create a Drizzle D1 instance from a custom D1 binding.
+* Use this when you have multiple D1 databases or need a non-default binding.
+*/
+declare function createDb(d1: D1Database): DrizzleD1Database$1;
+/**
+* Default Drizzle D1 instance — resolves the `DB` binding from the runtime
+* environment. When the Void plugin is active, this is replaced with a
+* schema-aware instance via virtual module.
+*/
+declare const db: DrizzleD1Database$1;
+//#endregion
+export { type DrizzleD1Database, and, asc, avg, between, count, createDb, db, desc, eq, exists, gt, gte, ilike, inArray, isNotNull, isNull, like, lt, lte, max, min, ne, not, notBetween, notExists, notInArray, notLike, or, sql, sum };

package/dist/runtime/db.mjs

@@ -0,0 +1,30 @@
+import { requireRuntimeBinding } from "./env.mjs";
+import { drizzle } from "drizzle-orm/d1";
+import { and, asc, avg, between, count, desc, eq, exists, gt, gte, ilike, inArray, isNotNull, isNull, like, lt, lte, max, min, ne, not, notBetween, notExists, notInArray, notLike, or, sql, sum } from "drizzle-orm";
+//#region src/runtime/db.ts
+/**
+* void/db — Drizzle-powered database access.
+*
+* At build time, the Void plugin intercepts this import and serves a
+* virtual module that auto-wires the D1 binding with the user's schema.
+* This stub exists for the published npm package and type declarations.
+*/
+/**
+* Create a Drizzle D1 instance from a custom D1 binding.
+* Use this when you have multiple D1 databases or need a non-default binding.
+*/
+function createDb(d1) {
+	return drizzle(d1);
+}
+let _instance;
+/**
+* Default Drizzle D1 instance — resolves the `DB` binding from the runtime
+* environment. When the Void plugin is active, this is replaced with a
+* schema-aware instance via virtual module.
+*/
+const db = new Proxy({}, { get(_, prop) {
+	_instance ??= drizzle(requireRuntimeBinding("DB"));
+	return Reflect.get(_instance, prop);
+} });
+//#endregion
+export { and, asc, avg, between, count, createDb, db, desc, eq, exists, gt, gte, ilike, inArray, isNotNull, isNull, like, lt, lte, max, min, ne, not, notBetween, notExists, notInArray, notLike, or, sql, sum };

package/dist/runtime/drizzle-arktype.d.mts

@@ -0,0 +1 @@
+export * from "drizzle-arktype";

package/dist/runtime/drizzle-arktype.mjs

@@ -0,0 +1,2 @@
+export * from "drizzle-arktype";
+export {};

package/dist/runtime/drizzle-valibot.d.mts

@@ -0,0 +1 @@
+export * from "drizzle-valibot";

package/dist/runtime/drizzle-valibot.mjs

@@ -0,0 +1,2 @@
+export * from "drizzle-valibot";
+export {};

package/dist/runtime/drizzle-zod.d.mts

@@ -0,0 +1 @@
+export * from "drizzle-zod";

package/dist/runtime/drizzle-zod.mjs

@@ -0,0 +1,2 @@
+export * from "drizzle-zod";
+export {};

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

@@ -0,0 +1,2 @@
+import { a as getSecretOverride, c as oneOf, i as email, l as string, n as SECRET_OVERRIDE_SYMBOL, o as json, r as boolean, s as number, t as EnvSchema, u as url } from "../env-helpers-Dr9Y7RnE.mjs";
+export { EnvSchema, SECRET_OVERRIDE_SYMBOL, boolean, email, getSecretOverride, json, number, oneOf, string, url };

package/dist/runtime/env-helpers.mjs

@@ -0,0 +1,173 @@
+//#region src/runtime/env-helpers.ts
+/**
+* Marker property read by the mask helpers. Present only on built-in
+* schema builders; third-party Standard Schema validators fall back to the
+* name/value heuristic (documented in `docs/guide/env-vars.md`).
+*/
+const SECRET_OVERRIDE_SYMBOL = Symbol.for("void.env.secretOverride");
+/**
+* Pull the explicit `.secret()` / `.public()` flag off a Standard Schema
+* validator, if it was authored through our built-in helpers. Returns
+* `undefined` for third-party validators (valibot, zod, arktype, …) —
+* they are redacted purely via the heuristic.
+*/
+function getSecretOverride(validator) {
+	if (!validator || typeof validator !== "object") return;
+	return validator[SECRET_OVERRIDE_SYMBOL];
+}
+function build(parse, state) {
+	const schema = {
+		"~standard": {
+			version: 1,
+			vendor: "void",
+			validate(value) {
+				if (value === void 0 || value === null || value === "") {
+					if (state.defaultValue !== void 0) return { value: state.defaultValue };
+					if (state.optional) return { value: void 0 };
+					return { issues: [{ message: "Required" }] };
+				}
+				const result = parse(typeof value === "string" ? value : String(value));
+				if (result.ok) return { value: result.value };
+				return { issues: [{ message: result.message }] };
+			}
+		},
+		optional() {
+			return build(parse, {
+				optional: true,
+				defaultValue: state.defaultValue,
+				secretOverride: state.secretOverride
+			});
+		},
+		default(value) {
+			return build(parse, {
+				optional: false,
+				defaultValue: value,
+				secretOverride: state.secretOverride
+			});
+		},
+		secret() {
+			return build(parse, {
+				...state,
+				secretOverride: "secret"
+			});
+		},
+		public() {
+			return build(parse, {
+				...state,
+				secretOverride: "public"
+			});
+		}
+	};
+	Object.defineProperty(schema, SECRET_OVERRIDE_SYMBOL, {
+		value: state.secretOverride,
+		enumerable: false,
+		configurable: true
+	});
+	return schema;
+}
+const empty = () => ({
+	optional: false,
+	defaultValue: void 0,
+	secretOverride: void 0
+});
+/** Required string env value. */
+function string() {
+	return build((raw) => ({
+		ok: true,
+		value: raw
+	}), empty());
+}
+/** Numeric env value. Parses with `Number(raw)`; rejects NaN. */
+function number() {
+	return build((raw) => {
+		const n = Number(raw);
+		if (Number.isNaN(n)) return {
+			ok: false,
+			message: `Expected a number, got "${raw}"`
+		};
+		return {
+			ok: true,
+			value: n
+		};
+	}, empty());
+}
+/** Boolean env value. Accepts "true"/"false"/"1"/"0" (case-insensitive). */
+function boolean() {
+	return build((raw) => {
+		const lc = raw.toLowerCase();
+		if (lc === "true" || lc === "1") return {
+			ok: true,
+			value: true
+		};
+		if (lc === "false" || lc === "0") return {
+			ok: true,
+			value: false
+		};
+		return {
+			ok: false,
+			message: `Expected boolean (true/false/1/0), got "${raw}"`
+		};
+	}, empty());
+}
+/** URL string — validated via `new URL(raw)`. */
+function url() {
+	return build((raw) => {
+		try {
+			new URL(raw);
+			return {
+				ok: true,
+				value: raw
+			};
+		} catch {
+			return {
+				ok: false,
+				message: `Expected a valid URL, got "${raw}"`
+			};
+		}
+	}, empty());
+}
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+/** Email string — basic shape validation. */
+function email() {
+	return build((raw) => {
+		if (!EMAIL_RE.test(raw)) return {
+			ok: false,
+			message: `Expected a valid email, got "${raw}"`
+		};
+		return {
+			ok: true,
+			value: raw
+		};
+	}, empty());
+}
+/** One of a fixed set of literal string values. */
+function oneOf(values) {
+	return build((raw) => {
+		if (values.includes(raw)) return {
+			ok: true,
+			value: raw
+		};
+		return {
+			ok: false,
+			message: `Expected one of ${values.join(", ")}, got "${raw}"`
+		};
+	}, empty());
+}
+/** JSON-parsed env value. Specify `T` to type the parsed result. */
+function json() {
+	return build((raw) => {
+		try {
+			return {
+				ok: true,
+				value: JSON.parse(raw)
+			};
+		} catch (e) {
+			return {
+				ok: false,
+				message: `Invalid JSON: ${e.message}`
+			};
+		}
+	}, empty());
+}
+//#endregion
+export { SECRET_OVERRIDE_SYMBOL, boolean, email, getSecretOverride, json, number, oneOf, string, url };

package/dist/runtime/env-public-client.d.mts

@@ -0,0 +1,22 @@
+import { c as oneOf, i as email, l as string, o as json, r as boolean, s as number, t as EnvSchema, u as url } from "../env-helpers-Dr9Y7RnE.mjs";
+
+//#region src/runtime/env-public-client.d.ts
+declare const env: Record<string, unknown>;
+/**
+* In client builds `defineEnv` is a no-op identity function — schema
+* registration only happens server-side. We still return the `env` proxy so
+* t3-style `export const env = defineEnv({...})` keeps working in shared
+* modules.
+*/
+declare function defineEnv<S>(_schema: S): typeof env;
+declare class EnvValidationError extends Error {
+  readonly key: string;
+  readonly issues: ReadonlyArray<{
+    message: string;
+  }>;
+  constructor(key: string, issues: ReadonlyArray<{
+    message: string;
+  }>);
+}
+//#endregion
+export { type EnvSchema, EnvValidationError, boolean, defineEnv, email, env, json, number, oneOf, string, url };

package/dist/runtime/env-public-client.mjs

@@ -0,0 +1,54 @@
+import { boolean, email, json, number, oneOf, string, url } from "./env-helpers.mjs";
+//#region src/runtime/env-public-client.ts
+function getClientEnv() {
+	return import.meta.env;
+}
+function readClientKey(key) {
+	const meta = getClientEnv();
+	if (meta && key in meta) return meta[key];
+	throw new Error(`env: Key '${key}' is not exposed to the client. Vite only injects keys matching the configured envPrefix (default: VITE_*). Either rename the key in env.ts to match envPrefix, or move this access to a server module.`);
+}
+const env = new Proxy({}, {
+	get(_target, key) {
+		if (typeof key === "symbol") return;
+		return readClientKey(String(key));
+	},
+	has(_target, key) {
+		if (typeof key !== "string") return false;
+		const meta = getClientEnv();
+		return meta ? key in meta : false;
+	},
+	ownKeys() {
+		const meta = getClientEnv();
+		return meta ? Object.keys(meta) : [];
+	},
+	getOwnPropertyDescriptor(_target, key) {
+		if (typeof key !== "string") return;
+		const meta = getClientEnv();
+		if (!meta || !(key in meta)) return;
+		return {
+			enumerable: true,
+			configurable: true,
+			value: meta[key]
+		};
+	}
+});
+/**
+* In client builds `defineEnv` is a no-op identity function — schema
+* registration only happens server-side. We still return the `env` proxy so
+* t3-style `export const env = defineEnv({...})` keeps working in shared
+* modules.
+*/
+function defineEnv(_schema) {
+	return env;
+}
+var EnvValidationError = class extends Error {
+	constructor(key, issues) {
+		super(`Invalid env "${key}": ${issues.map((i) => i.message).join(", ")}`);
+		this.key = key;
+		this.issues = issues;
+		this.name = "EnvValidationError";
+	}
+};
+//#endregion
+export { EnvValidationError, boolean, defineEnv, email, env, json, number, oneOf, string, url };

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

@@ -0,0 +1,143 @@
+/// <reference types="@cloudflare/workers-types" />
+import { t as StandardSchemaV1 } from "../standard-schema-9CRjx-uR.mjs";
+import { c as oneOf, i as email, l as string, o as json, r as boolean, s as number, t as EnvSchema, u as url } from "../env-helpers-Dr9Y7RnE.mjs";
+import * as _$_cloudflare_sandbox0 from "@cloudflare/sandbox";
+
+//#region src/runtime/env-public.d.ts
+interface AnyValidator extends 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 by the plugin and deploy CLI to seed worker
+* `vars` so `c.env.X` and `process.env.X` see the same fallback that the
+* typed `env.X` proxy returns.
+*
+* 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, plain `.optional()` — are omitted
+* from the result so they don't shadow user `.env*` entries with empty
+* strings.
+*/
+declare function _getSchemaDefaults(): Record<string, string>;
+declare class EnvValidationError extends Error {
+  readonly key: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(key: string, issues: ReadonlyArray<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. */
+interface 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 (e.g. merged `.env*` + remote secret list) 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<_$_cloudflare_sandbox0.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 { type EnvSchema, EnvValidationError, EnvValidationReport, ValidatedEnv, _getRegisteredSchema, _getSchemaDefaults, _hasRegisteredSchema, _validateEnvOnce, boolean, defineEnv, email, env, json, number, oneOf, string, url, validateAllEnv };