@ayepi/env 0.2.0

package/dist/index.js

@@ -0,0 +1,722 @@
+import { t as parseDotenv } from "./dotenv.js";
+//#region src/coerce.ts
+/** Read a schema's internal `_zod.def` (zod v4 stores its definition there). */
+function def(schema) {
+	return schema._zod.def;
+}
+/** Wrapper types that hold an `innerType` we look through to find the effective leaf type. */
+const WRAPPERS = new Set([
+	"optional",
+	"nullable",
+	"default",
+	"prefault",
+	"catch",
+	"readonly",
+	"nonoptional"
+]);
+/** The effective (unwrapped) zod type name of a field — e.g. `optional(number)` → `'number'`. */
+function effectiveType(schema) {
+	let d = def(schema);
+	while (WRAPPERS.has(d.type)) d = def(d.innerType);
+	return d.type;
+}
+/** The default strings parsed as `true` / `false` (matched case-insensitively, trimmed). */
+const DEFAULT_TRUE = new Set([
+	"true",
+	"1",
+	"yes",
+	"y",
+	"on"
+]);
+const DEFAULT_FALSE = new Set([
+	"false",
+	"0",
+	"no",
+	"n",
+	"off"
+]);
+/** Parse a boolean-ish string; `undefined` when it isn't recognizably boolean. */
+function toBool(value, words) {
+	const v = value.trim().toLowerCase();
+	if ((words?.true ?? DEFAULT_TRUE).has(v)) return true;
+	if ((words?.false ?? DEFAULT_FALSE).has(v)) return false;
+}
+/** `JSON.parse` the string, or return it unchanged if it isn't valid JSON. */
+function tryJson(value) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+/** Complex zod types whose string form is JSON. */
+const JSONISH = new Set([
+	"object",
+	"array",
+	"tuple",
+	"record",
+	"map",
+	"set",
+	"union",
+	"intersection",
+	"json"
+]);
+/**
+* Coerce `value` toward what `schema` expects. Non-string values pass through; strings are
+* converted per the field's effective type — so a plain `z.number()` / `z.boolean()` / `z.date()`
+* / `z.object()` works straight from env strings, **no `z.coerce` needed**. Returns the original
+* string when a conversion is ambiguous or fails, so zod produces the final, authoritative error.
+* Pass `words` to customize which strings count as boolean `true`/`false`.
+*/
+function coerce(schema, value, words) {
+	if (typeof value !== "string") return value;
+	const t = effectiveType(schema);
+	switch (t) {
+		case "number": {
+			const n = Number(value);
+			return value.trim() === "" || Number.isNaN(n) ? value : n;
+		}
+		case "bigint": try {
+			return BigInt(value);
+		} catch {
+			return value;
+		}
+		case "boolean": {
+			const b = toBool(value, words);
+			return b === void 0 ? value : b;
+		}
+		case "date": {
+			const d = new Date(value);
+			return Number.isNaN(d.getTime()) ? value : d;
+		}
+		default: return JSONISH.has(t) ? tryJson(value) : value;
+	}
+}
+//#endregion
+//#region src/meta.ts
+/** Read a schema's `.meta()` (zod v4), narrowed to the aliasing keys we understand. */
+function readMeta(schema) {
+	return schema.meta?.();
+}
+/** The source keys a field reads, in precedence order — its `vars`/`var` meta, else `[key]`. */
+function varsOf(schema, key) {
+	const meta = readMeta(schema);
+	if (meta?.vars && meta.vars.length > 0) return meta.vars;
+	if (meta?.var) return [meta.var];
+	return [key];
+}
+/** Attach aliasing metadata: read `schema` from the first present of `keys`. */
+function alias(schema, ...keys) {
+	return schema.meta({ vars: keys });
+}
+//#endregion
+//#region src/source.ts
+/** `process.env` when available (Node), else an empty record (so the core stays browser-safe). */
+function defaultSource() {
+	return globalThis.process?.env ?? {};
+}
+/** Flatten one or more sources into a single record; later sources win. */
+function mergeSources(source) {
+	const list = source === void 0 ? [defaultSource()] : Array.isArray(source) ? source : [source];
+	return Object.assign({}, ...list);
+}
+/** Resolve a value from the first present (defined) of several source `keys` (**aliasing**). */
+function resolveRaw(source, keys) {
+	for (const k of keys) {
+		const v = source[k];
+		if (v !== void 0) return v;
+	}
+}
+/** A readable, aggregated environment validation error built from zod issues. */
+var EnvError = class extends Error {
+	/** The individual zod issues that caused the failure. */
+	issues;
+	constructor(issues) {
+		const lines = issues.map((i) => `  ${i.path.join(".") || "(root)"}: ${i.message}`);
+		super(`Invalid environment:\n${lines.join("\n")}`);
+		this.name = "EnvError";
+		this.issues = issues;
+	}
+};
+/** Prefix a field key onto each issue's path (for aggregated, keyed error messages). */
+function keyed(key, issues) {
+	return issues.map((i) => ({
+		...i,
+		path: [key, ...i.path]
+	}));
+}
+/** A custom single-issue for a field (a thrown factory, or a value with no schema that failed). */
+function customIssue(key, message) {
+	return {
+		code: "custom",
+		path: [key],
+		message
+	};
+}
+/** Message text for a thrown value (Error or otherwise). */
+function errMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+//#region src/util.ts
+/** True if `x` is a zod schema (zod v4 stores its definition under `_zod` and exposes `safeParse`). */
+function isZodType(x) {
+	return typeof x === "object" && x !== null && "_zod" in x && typeof x.safeParse === "function";
+}
+/** Structural deep equality (for `deep` change detection): handles arrays, plain objects, dates, NaN. */
+function deepEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (a instanceof Date || b instanceof Date) return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+	const aArr = Array.isArray(a);
+	if (aArr !== Array.isArray(b)) return false;
+	if (aArr) {
+		const x = a;
+		const y = b;
+		return x.length === y.length && x.every((v, i) => deepEqual(v, y[i]));
+	}
+	const ak = Object.keys(a);
+	const bk = Object.keys(b);
+	return ak.length === bk.length && ak.every((k) => Object.prototype.hasOwnProperty.call(b, k) && deepEqual(a[k], b[k]));
+}
+/** Equality used for change detection: structural when `deep`, else identity (`Object.is`). */
+function changed(prev, next, deep) {
+	return deep ? !deepEqual(prev, next) : !Object.is(prev, next);
+}
+//#endregion
+//#region src/env.ts
+/** Normalize {@link EnvOptions} into the lowercased {@link BooleanWords} the coercer consumes. */
+function toWords(options) {
+	const b = options?.booleans;
+	if (!b) return;
+	const lower = (xs) => xs ? new Set(xs.map((s) => s.trim().toLowerCase())) : void 0;
+	return {
+		true: lower(b.true),
+		false: lower(b.false)
+	};
+}
+/** The synchronous engine behind {@link env} (cast to the typed {@link Env} surface by `env`/`add`). */
+var EnvImpl = class {
+	defs = /* @__PURE__ */ new Map();
+	overrides = {};
+	cache = /* @__PURE__ */ new Map();
+	deps = /* @__PURE__ */ new Map();
+	keyLs = /* @__PURE__ */ new Map();
+	globalLs = /* @__PURE__ */ new Set();
+	prev = /* @__PURE__ */ new Map();
+	words;
+	groupCount = 0;
+	constructor(input, options) {
+		this.words = toWords(options);
+		this.define(input);
+	}
+	/** Register a group of fields under the next group index. */
+	define(input) {
+		const group = this.groupCount++;
+		for (const [key, val] of Object.entries(input)) if (isZodType(val)) this.defs.set(key, {
+			kind: "schema",
+			key,
+			group,
+			schema: val
+		});
+		else this.defs.set(key, {
+			kind: "factory",
+			key,
+			group,
+			factory: val
+		});
+	}
+	/** The live source: `process.env` (or `{}`), with `set(...)` overrides on top. */
+	source() {
+		return Object.assign({}, defaultSource(), this.overrides);
+	}
+	/** A proxy over fields from groups *earlier* than `group`, recording which keys a factory reads. */
+	inheritedFor(group) {
+		const reads = /* @__PURE__ */ new Set();
+		const self = this;
+		const visible = (prop) => typeof prop === "string" && (self.defs.get(prop)?.group ?? Infinity) < group;
+		return {
+			proxy: new Proxy(Object.create(null), {
+				get: (_t, prop) => visible(prop) ? (reads.add(prop), self.resolve(prop)) : void 0,
+				has: (_t, prop) => visible(prop),
+				ownKeys: () => [...self.defs.values()].filter((f) => f.group < group).map((f) => f.key),
+				getOwnPropertyDescriptor: () => ({
+					enumerable: true,
+					configurable: true
+				})
+			}),
+			reads
+		};
+	}
+	/** Resolve `key` to its value (cached). Throws an {@link EnvError} (scoped to `key`) on failure. */
+	resolve(key) {
+		if (this.cache.has(key)) return this.cache.get(key);
+		const def = this.defs.get(key);
+		let schema;
+		let computed;
+		let isComputed = false;
+		if (def.kind === "schema") schema = def.schema;
+		else {
+			const { proxy, reads } = this.inheritedFor(def.group);
+			let produced;
+			try {
+				produced = def.factory(proxy);
+			} catch (err) {
+				this.deps.set(key, reads);
+				throw new EnvError([customIssue(key, errMessage(err))]);
+			}
+			this.deps.set(key, reads);
+			if (isZodType(produced)) schema = produced;
+			else {
+				computed = produced;
+				isComputed = true;
+			}
+		}
+		let result;
+		if (isComputed) result = computed;
+		else {
+			const raw = resolveRaw(this.source(), varsOf(schema, key));
+			const res = schema.safeParse(raw !== void 0 ? coerce(schema, raw, this.words) : void 0);
+			if (!res.success) throw new EnvError(keyed(key, res.error.issues));
+			result = res.data;
+		}
+		this.cache.set(key, result);
+		return result;
+	}
+	get(key) {
+		return this.resolve(key);
+	}
+	parse() {
+		const out = {};
+		const issues = [];
+		for (const key of this.defs.keys()) try {
+			out[key] = this.resolve(key);
+		} catch (err) {
+			issues.push(...err.issues);
+		}
+		if (issues.length > 0) throw new EnvError(issues);
+		return out;
+	}
+	set(keyOrUpdates, value) {
+		const updates = typeof keyOrUpdates === "string" ? { [keyOrUpdates]: value } : keyOrUpdates;
+		Object.assign(this.overrides, updates);
+		this.invalidate();
+	}
+	add(input) {
+		this.define(input);
+		this.cache.clear();
+		this.deps.clear();
+		return this;
+	}
+	with(fn) {
+		fn(this);
+	}
+	map(fn) {
+		return fn(this);
+	}
+	on(arg1, arg2, arg3) {
+		if (typeof arg1 === "function") return this.onGlobal(arg1, arg2);
+		const keys = Array.isArray(arg1) ? arg1 : [arg1];
+		return this.onKeys(keys, arg2, arg3);
+	}
+	/** Call a subscriber, swallowing any throw so one bad listener can't break the engine. */
+	fire(thunk) {
+		try {
+			thunk();
+		} catch {}
+	}
+	/** Ensure `prev` holds a baseline for `key` (so the next change can be detected). */
+	baseline(key) {
+		if (this.prev.has(key)) return;
+		try {
+			this.prev.set(key, this.resolve(key));
+		} catch {}
+	}
+	removeKeyListener(l) {
+		for (const k of l.keys) {
+			const set = this.keyLs.get(k);
+			if (set) {
+				set.delete(l);
+				if (set.size === 0) this.keyLs.delete(k);
+			}
+		}
+	}
+	invokeKey(l, value, key) {
+		this.fire(() => l.fn(value, key));
+		if (l.opts.once) this.removeKeyListener(l);
+	}
+	invokeGlobal(l, key, value) {
+		this.fire(() => l.fn(key, value));
+		if (l.opts.once) this.globalLs.delete(l);
+	}
+	onGlobal(fn, opts) {
+		const l = {
+			fn,
+			opts: opts ?? {}
+		};
+		this.globalLs.add(l);
+		for (const key of this.defs.keys()) this.baseline(key);
+		if (l.opts.immediate) for (const key of this.defs.keys()) {
+			if (!this.globalLs.has(l)) break;
+			try {
+				const v = this.resolve(key);
+				this.invokeGlobal(l, key, v);
+			} catch {}
+		}
+		return () => this.globalLs.delete(l);
+	}
+	onKeys(keys, fn, opts) {
+		const l = {
+			fn,
+			opts: opts ?? {},
+			keys
+		};
+		for (const key of keys) {
+			let set = this.keyLs.get(key);
+			if (!set) this.keyLs.set(key, set = /* @__PURE__ */ new Set());
+			set.add(l);
+			this.baseline(key);
+		}
+		if (l.opts.immediate) for (const key of keys) {
+			if (l.opts.once && !this.keyLs.get(key)?.has(l)) break;
+			try {
+				const v = this.resolve(key);
+				this.invokeKey(l, v, key);
+			} catch {}
+		}
+		return () => this.removeKeyListener(l);
+	}
+	/** After a `set(...)`: drop caches and notify listeners whose watched values changed. */
+	invalidate() {
+		const hasGlobal = this.globalLs.size > 0;
+		const watched = new Set(this.keyLs.keys());
+		if (hasGlobal) for (const k of this.defs.keys()) watched.add(k);
+		this.cache.clear();
+		this.deps.clear();
+		for (const key of watched) {
+			let next;
+			try {
+				next = this.resolve(key);
+			} catch {
+				continue;
+			}
+			const hadPrev = this.prev.has(key);
+			const old = this.prev.get(key);
+			this.prev.set(key, next);
+			if (!hadPrev) continue;
+			const keyLs = this.keyLs.get(key);
+			if (keyLs) {
+				for (const l of [...keyLs]) if (changed(old, next, l.opts.deep)) this.invokeKey(l, next, key);
+			}
+			for (const g of [...this.globalLs]) if (changed(old, next, g.opts.deep)) this.invokeGlobal(g, key, next);
+		}
+	}
+};
+/** Build a typed, lazy, reactive config from a record of fields. Reads `process.env` by default. */
+function env(input, options) {
+	return new EnvImpl(input, options);
+}
+//#endregion
+//#region src/provider.ts
+/** Bind a field to a live {@link EnvProvider}; values are validated against `schema`. */
+function dynamic(provider, schema) {
+	return {
+		kind: "dynamic",
+		provider,
+		schema
+	};
+}
+/** True if `x` is a {@link DynamicBinding}. */
+function isDynamic(x) {
+	return typeof x === "object" && x !== null && x.kind === "dynamic";
+}
+/** A provider that re-fetches on an interval — the simplest way to make any source "dynamic". */
+function pollProvider(fetch, intervalMs) {
+	return {
+		load: fetch,
+		watch(emit) {
+			const id = setInterval(() => {
+				(async () => {
+					try {
+						emit(await fetch());
+					} catch {}
+				})();
+			}, intervalMs);
+			return () => clearInterval(id);
+		}
+	};
+}
+/** A fixed-value provider (no updates) — handy for tests and constants behind the provider interface. */
+function staticProvider(value) {
+	return { load: () => value };
+}
+//#endregion
+//#region src/async.ts
+/** The asynchronous engine behind {@link asyncEnv}. */
+var AsyncEnvImpl = class {
+	defs = /* @__PURE__ */ new Map();
+	overrides = {};
+	cache = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	deps = /* @__PURE__ */ new Map();
+	keyLs = /* @__PURE__ */ new Map();
+	globalLs = /* @__PURE__ */ new Set();
+	prev = /* @__PURE__ */ new Map();
+	dynamicRaw = /* @__PURE__ */ new Map();
+	started = /* @__PURE__ */ new Set();
+	watchers = /* @__PURE__ */ new Map();
+	words;
+	groupCount = 0;
+	constructor(input, options) {
+		this.words = toWords(options);
+		this.define(input);
+	}
+	define(input) {
+		const group = this.groupCount++;
+		for (const [key, val] of Object.entries(input)) if (isDynamic(val)) this.defs.set(key, {
+			kind: "dynamic",
+			key,
+			group,
+			provider: val.provider,
+			schema: val.schema
+		});
+		else if (isZodType(val)) this.defs.set(key, {
+			kind: "schema",
+			key,
+			group,
+			schema: val
+		});
+		else this.defs.set(key, {
+			kind: "factory",
+			key,
+			group,
+			factory: val
+		});
+	}
+	source() {
+		return Object.assign({}, defaultSource(), this.overrides);
+	}
+	/** Validate a raw string against `schema` (coercing first); throws a keyed {@link EnvError} on failure. */
+	validate(schema, key, raw) {
+		const res = schema.safeParse(raw !== void 0 ? coerce(schema, raw, this.words) : void 0);
+		if (!res.success) throw new EnvError(keyed(key, res.error.issues));
+		return res.data;
+	}
+	/** Ensure a dynamic field's provider has loaded once and (if able) is watching for live updates. */
+	async ensureStarted(def) {
+		if (this.started.has(def.key)) return;
+		this.started.add(def.key);
+		this.dynamicRaw.set(def.key, await def.provider.load());
+		if (def.provider.watch) this.watchers.set(def.key, def.provider.watch((raw) => this.onDynamic(def, raw)));
+	}
+	/** A live push from a provider: keep the last good value on a bad update, else apply + notify. */
+	onDynamic(def, raw) {
+		if (!def.schema.safeParse(raw !== void 0 ? coerce(def.schema, raw, this.words) : void 0).success) return;
+		this.dynamicRaw.set(def.key, raw);
+		this.emitChange();
+	}
+	/** Resolve every field in groups *earlier* than `group` into a plain snapshot object. */
+	async earlierSnapshot(group) {
+		const earlier = [...this.defs.values()].filter((f) => f.group < group);
+		const entries = await Promise.all(earlier.map(async (f) => [f.key, await this.resolve(f.key)]));
+		return Object.fromEntries(entries);
+	}
+	/** Do the work of resolving one field (no memoization — see {@link resolve}). */
+	async compute(key) {
+		const def = this.defs.get(key);
+		if (def.kind === "schema") return this.validate(def.schema, key, resolveRaw(this.source(), varsOf(def.schema, key)));
+		if (def.kind === "dynamic") {
+			await this.ensureStarted(def);
+			return this.validate(def.schema, key, this.dynamicRaw.get(def.key));
+		}
+		const snap = await this.earlierSnapshot(def.group);
+		const reads = /* @__PURE__ */ new Set();
+		const proxy = new Proxy(snap, {
+			get: (t, p) => typeof p === "string" && p in t ? (reads.add(p), t[p]) : void 0,
+			has: (t, p) => typeof p === "string" && p in t
+		});
+		let produced;
+		try {
+			produced = await def.factory(proxy);
+		} catch (err) {
+			this.deps.set(key, reads);
+			throw new EnvError([customIssue(key, errMessage(err))]);
+		}
+		this.deps.set(key, reads);
+		if (isZodType(produced)) return this.validate(produced, key, resolveRaw(this.source(), varsOf(produced, key)));
+		return produced;
+	}
+	/** Resolve `key` (memoized per snapshot). Cleared by `set`/provider updates. */
+	resolve(key) {
+		if (this.cache.has(key)) return Promise.resolve(this.cache.get(key));
+		let p = this.pending.get(key);
+		if (!p) {
+			p = this.compute(key).then((v) => {
+				this.cache.set(key, v);
+				this.pending.delete(key);
+				return v;
+			}, (err) => {
+				this.pending.delete(key);
+				throw err;
+			});
+			this.pending.set(key, p);
+		}
+		return p;
+	}
+	get(key) {
+		return this.resolve(key);
+	}
+	async parse() {
+		const out = {};
+		const issues = [];
+		await Promise.all([...this.defs.keys()].map(async (key) => {
+			try {
+				out[key] = await this.resolve(key);
+			} catch (err) {
+				issues.push(...err.issues);
+			}
+		}));
+		if (issues.length > 0) throw new EnvError(issues);
+		return out;
+	}
+	set(keyOrUpdates, value) {
+		const updates = typeof keyOrUpdates === "string" ? { [keyOrUpdates]: value } : keyOrUpdates;
+		Object.assign(this.overrides, updates);
+		this.emitChange();
+	}
+	add(input) {
+		this.define(input);
+		this.cache.clear();
+		this.pending.clear();
+		this.deps.clear();
+		return this;
+	}
+	with(fn) {
+		fn(this);
+	}
+	map(fn) {
+		return fn(this);
+	}
+	async refresh(key) {
+		const keys = (key !== void 0 ? [key] : [...this.defs.keys()]).filter((k) => this.defs.get(k)?.kind === "dynamic");
+		let any = false;
+		for (const k of keys) {
+			const def = this.defs.get(k);
+			await this.ensureStarted(def);
+			const raw = await def.provider.load();
+			if (def.schema.safeParse(raw !== void 0 ? coerce(def.schema, raw, this.words) : void 0).success) {
+				this.dynamicRaw.set(k, raw);
+				any = true;
+			}
+		}
+		if (any) await this.emitChange();
+	}
+	close() {
+		for (const un of this.watchers.values()) un();
+		this.watchers.clear();
+	}
+	on(arg1, arg2, arg3) {
+		if (typeof arg1 === "function") return this.onGlobal(arg1, arg2);
+		const keys = Array.isArray(arg1) ? arg1 : [arg1];
+		return this.onKeys(keys, arg2, arg3);
+	}
+	fire(thunk) {
+		try {
+			thunk();
+		} catch {}
+	}
+	async baseline(key) {
+		if (this.prev.has(key)) return;
+		try {
+			this.prev.set(key, await this.resolve(key));
+		} catch {}
+	}
+	removeKeyListener(l) {
+		for (const k of l.keys) {
+			const set = this.keyLs.get(k);
+			if (set) {
+				set.delete(l);
+				if (set.size === 0) this.keyLs.delete(k);
+			}
+		}
+	}
+	invokeKey(l, value, key) {
+		this.fire(() => l.fn(value, key));
+		if (l.opts.once) this.removeKeyListener(l);
+	}
+	invokeGlobal(l, key, value) {
+		this.fire(() => l.fn(key, value));
+		if (l.opts.once) this.globalLs.delete(l);
+	}
+	onGlobal(fn, opts) {
+		const l = {
+			fn,
+			opts: opts ?? {}
+		};
+		this.globalLs.add(l);
+		(async () => {
+			for (const key of this.defs.keys()) await this.baseline(key);
+			if (l.opts.immediate) for (const key of this.defs.keys()) {
+				if (!this.globalLs.has(l)) break;
+				try {
+					this.invokeGlobal(l, key, await this.resolve(key));
+				} catch {}
+			}
+		})();
+		return () => this.globalLs.delete(l);
+	}
+	onKeys(keys, fn, opts) {
+		const l = {
+			fn,
+			opts: opts ?? {},
+			keys
+		};
+		for (const key of keys) {
+			let set = this.keyLs.get(key);
+			if (!set) this.keyLs.set(key, set = /* @__PURE__ */ new Set());
+			set.add(l);
+		}
+		(async () => {
+			for (const key of keys) await this.baseline(key);
+			if (l.opts.immediate) for (const key of keys) {
+				if (l.opts.once && !this.keyLs.get(key)?.has(l)) break;
+				try {
+					this.invokeKey(l, await this.resolve(key), key);
+				} catch {}
+			}
+		})();
+		return () => this.removeKeyListener(l);
+	}
+	/** After a change: drop caches and notify listeners whose watched values changed. */
+	async emitChange() {
+		const hasGlobal = this.globalLs.size > 0;
+		const watched = new Set(this.keyLs.keys());
+		if (hasGlobal) for (const k of this.defs.keys()) watched.add(k);
+		this.cache.clear();
+		this.pending.clear();
+		this.deps.clear();
+		for (const key of watched) {
+			let next;
+			try {
+				next = await this.resolve(key);
+			} catch {
+				continue;
+			}
+			const hadPrev = this.prev.has(key);
+			const old = this.prev.get(key);
+			this.prev.set(key, next);
+			if (!hadPrev) continue;
+			const keyLs = this.keyLs.get(key);
+			if (keyLs) {
+				for (const l of [...keyLs]) if (changed(old, next, l.opts.deep)) this.invokeKey(l, next, key);
+			}
+			for (const g of [...this.globalLs]) if (changed(old, next, g.opts.deep)) this.invokeGlobal(g, key, next);
+		}
+	}
+};
+/** Build a typed, lazy, reactive **async** config — supports async factories and live providers. */
+function asyncEnv(input, options) {
+	return new AsyncEnvImpl(input, options);
+}
+//#endregion
+export { DEFAULT_FALSE, DEFAULT_TRUE, EnvError, alias, asyncEnv, coerce, defaultSource, dynamic, effectiveType, env, isDynamic, mergeSources, parseDotenv, pollProvider, resolveRaw, staticProvider, varsOf };