@arkenv/core 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/index.cjs

@@ -2,243 +2,490 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 let arktype = require("arktype");
 
 //#region ../internal/scope/dist/index.js
-const n$1 = (0, arktype.type)(`0 <= number.integer <= 65535`), r$1 = (0, arktype.type)(`string.ip | 'localhost'`), i$1 = (0, arktype.scope)({
+const n = (0, arktype.type)(`0 <= number.integer <= 65535`), r = (0, arktype.type)(`string.ip | 'localhost'`), i = (0, arktype.scope)({
 	string: arktype.type.module({
 		...arktype.type.keywords.string,
-		host: r$1
+		host: r
 	}),
 	number: arktype.type.module({
 		...arktype.type.keywords.number,
-		port: n$1
+		port: n
 	})
 });
 
+//#endregion
+//#region ../internal/utils/dist/boundary-access-error.js
+/**
+* `error.name` for the validation class {@link ArkEnvError}.
+*/
+const ARKENV_ERROR_NAME = "ArkEnvError";
+
 //#endregion
 //#region ../internal/utils/dist/index.js
-const e = (e) => {
-	if (typeof e == `number` || typeof e != `string` || !e.trim()) return e;
-	if (e.trim() === `NaN`) return NaN;
-	let t = Number(e);
-	return Number.isNaN(t) ? e : t;
-}, t = (e) => e === `true` ? !0 : e === `false` ? !1 : e, n = (e) => {
-	if (typeof e != `string`) return e;
-	let t = e.trim();
-	if (t[0] !== `{` && t[0] !== `[`) return e;
+/**
+* Attempt to coerce a value to a number.
+*
+* If the input is already a number, returns it unchanged.
+* If the input is a string that can be parsed as a number, returns the parsed number.
+* Otherwise, returns the original value unchanged.
+*
+* @internal
+* @param s - The value to coerce
+* @returns The coerced number or the original value
+*/
+const coerceNumber = (s) => {
+	if (typeof s === "number") return s;
+	if (typeof s !== "string" || !s.trim()) return s;
+	if (s.trim() === "NaN") return NaN;
+	const n = Number(s);
+	return Number.isNaN(n) ? s : n;
+};
+/**
+* Attempt to coerce a value to a boolean.
+*
+* Convert the strings "true" and "false" to their boolean equivalents.
+* All other values are returned unchanged.
+*
+* @internal
+* @param s - The value to coerce
+* @returns The coerced boolean or the original value
+*/
+const coerceBoolean = (s) => {
+	if (s === "true") return true;
+	if (s === "false") return false;
+	return s;
+};
+/**
+* Attempt to parse a value as JSON.
+*
+* If the input is a string that starts with `{` or `[` and can be parsed as JSON,
+* returns the parsed object or array. Otherwise, returns the original value unchanged.
+*
+* @internal
+* @param s - The value to parse
+* @returns The parsed JSON or the original value
+*/
+const coerceJson = (s) => {
+	if (typeof s !== "string") return s;
+	const trimmed = s.trim();
+	if (trimmed[0] !== "{" && trimmed[0] !== "[") return s;
 	try {
-		return JSON.parse(t);
+		return JSON.parse(trimmed);
 	} catch {
-		return e;
+		return s;
 	}
-}, r = (e) => {
-	if (e instanceof Date || typeof e != `string` || !e.trim()) return e;
-	let t = new Date(e);
-	return Number.isNaN(t.getTime()) ? e : t;
-}, i = (e) => {
-	let t = {};
-	for (let n in e) {
-		let r = e[n];
-		r !== `` && (t[n] = r);
+};
+/**
+* Attempt to coerce a value to a Date.
+*
+* If the input is already a Date, returns it unchanged.
+* If the input is a valid date string, returns a Date object.
+* Otherwise, returns the original value unchanged.
+*
+* @internal
+* @param s - The value to coerce
+* @returns The coerced Date or the original value
+*/
+const coerceDate = (s) => {
+	if (s instanceof Date) return s;
+	if (typeof s !== "string" || !s.trim()) return s;
+	const d = new Date(s);
+	return Number.isNaN(d.getTime()) ? s : d;
+};
+/**
+* Remove keys with empty string values from an environment record.
+*
+* When a key is set to `""` (e.g. `PORT=` in a `.env` file), deleting it
+* allows the validator to treat it as missing so that defaults apply.
+*
+* @param env The environment variables record
+* @returns A new record with empty string keys removed
+*/
+const stripEmptyStrings = (env) => {
+	const result = {};
+	for (const key in env) {
+		const value = env[key];
+		if (value !== "") result[key] = value;
 	}
-	return t;
-}, a = `*`, o = (e, t = []) => {
-	let n = [];
-	if (!e || typeof e != `object` || Array.isArray(e)) return n;
-	let r = e;
-	if (`const` in r) {
-		let e = typeof r.const;
-		(e === `number` || e === `boolean`) && n.push({
-			path: [...t],
-			type: `primitive`
+	return result;
+};
+/**
+* Find all paths in a JSON Schema that require coercion.
+*
+* Prioritize "number", "integer", "boolean", "array", "object", and "date" types.
+*
+* @param node The JSON Schema node to traverse
+* @param path The current path segments in the schema tree
+* @returns An array of coercion targets containing their path and type
+*/
+const findCoercionPaths = (node, path = []) => {
+	const results = [];
+	if (!node || typeof node !== "object" || Array.isArray(node)) return results;
+	const n = node;
+	if ("const" in n) {
+		const t = typeof n.const;
+		if (t === "number" || t === "boolean") results.push({
+			path: [...path],
+			type: "primitive"
 		});
 	}
-	`enum` in r && Array.isArray(r.enum) && r.enum.some((e) => typeof e == `number` || typeof e == `boolean`) && n.push({
-		path: [...t],
-		type: `primitive`
-	});
-	let i = r.type;
-	if (i === `number` || i === `integer` || i === `boolean`) n.push({
-		path: [...t],
-		type: `primitive`
+	if ("enum" in n && Array.isArray(n.enum)) {
+		if (n.enum.some((v) => typeof v === "number" || typeof v === "boolean")) results.push({
+			path: [...path],
+			type: "primitive"
+		});
+	}
+	const type = n.type;
+	if (type === "number" || type === "integer" || type === "boolean") results.push({
+		path: [...path],
+		type: "primitive"
 	});
-	else if (i === `string` && `format` in r && (r.format === `date-time` || r.format === `date`)) n.push({
-		path: [...t],
-		type: `date`
+	else if (type === "string" && "format" in n && (n.format === "date-time" || n.format === "date")) results.push({
+		path: [...path],
+		type: "date"
 	});
-	else if (i === `object`) {
-		if (r.properties && Object.keys(r.properties).length > 0) {
-			n.push({
-				path: [...t],
-				type: `object`
+	else if (type === "object") {
+		if (n.properties && Object.keys(n.properties).length > 0) {
+			results.push({
+				path: [...path],
+				type: "object"
 			});
-			for (let e in r.properties) n.push(...o(r.properties[e], [...t, e]));
+			for (const key in n.properties) results.push(...findCoercionPaths(n.properties[key], [...path, key]));
 		}
-	} else i === `array` && (n.push({
-		path: [...t],
-		type: `array`
-	}), r.items && (Array.isArray(r.items) ? r.items.forEach((e, r) => {
-		n.push(...o(e, [...t, String(r)]));
-	}) : n.push(...o(r.items, [...t, `*`]))));
-	for (let e of [
-		`anyOf`,
-		`allOf`,
-		`oneOf`
-	]) if (r[e] && Array.isArray(r[e])) for (let i of r[e]) n.push(...o(i, t));
-	let a = /* @__PURE__ */ new Set();
-	return n.filter((e) => {
-		let t = e.path.join(`/`) + `:` + e.type;
-		return a.has(t) ? !1 : a.add(t);
+	} else if (type === "array") {
+		results.push({
+			path: [...path],
+			type: "array"
+		});
+		if (n.items) if (Array.isArray(n.items)) n.items.forEach((item, index) => {
+			results.push(...findCoercionPaths(item, [...path, String(index)]));
+		});
+		else results.push(...findCoercionPaths(n.items, [...path, "*"]));
+	}
+	for (const comb of [
+		"anyOf",
+		"allOf",
+		"oneOf"
+	]) if (n[comb] && Array.isArray(n[comb])) for (const branch of n[comb]) results.push(...findCoercionPaths(branch, path));
+	const seen = /* @__PURE__ */ new Set();
+	return results.filter((t) => {
+		const key = t.path.join("/") + ":" + t.type;
+		return seen.has(key) ? false : seen.add(key);
 	});
-}, s = (i, a, o = {}) => {
-	let { arrayFormat: s = `comma` } = o, c = (e) => {
-		if (s === `json`) try {
-			return JSON.parse(e);
+};
+/**
+* Apply coercion to a data object based on identified paths.
+*
+* @param data The input environment data object to coerce
+* @param targets The coercion targets mapping paths to types
+* @param options The coercion options, including array parsing format
+* @returns The coerced data object
+*/
+const applyCoercion = (data, targets, options = {}) => {
+	const { arrayFormat = "comma" } = options;
+	const splitString = (val) => {
+		if (arrayFormat === "json") try {
+			return JSON.parse(val);
 		} catch {
-			return e;
+			return val;
 		}
-		return e.trim() ? e.split(`,`).map((e) => e.trim()) : [];
-	}, l = (i, a) => {
-		if (a === `array` && typeof i == `string`) return c(i);
-		if (a === `object` && typeof i == `string`) return n(i);
-		if (a === `date` && typeof i == `string`) return r(i);
-		if (a === `primitive`) {
-			if (Array.isArray(i)) return i.map((n) => {
-				if (typeof n != `string`) return n;
-				let r = e(n);
-				return typeof r == `number` ? r : t(n);
+		return val.trim() ? val.split(",").map((s) => s.trim()) : [];
+	};
+	const coerceValue = (val, type) => {
+		if (type === "array" && typeof val === "string") return splitString(val);
+		if (type === "object" && typeof val === "string") return coerceJson(val);
+		if (type === "date" && typeof val === "string") return coerceDate(val);
+		if (type === "primitive") {
+			if (Array.isArray(val)) return val.map((item) => {
+				if (typeof item !== "string") return item;
+				const n = coerceNumber(item);
+				return typeof n === "number" ? n : coerceBoolean(item);
 			});
-			if (typeof i != `string`) return i;
-			let n = e(i);
-			return typeof n == `number` ? n : t(i);
+			if (typeof val !== "string") return val;
+			const n = coerceNumber(val);
+			return typeof n === "number" ? n : coerceBoolean(val);
 		}
-		return i;
+		return val;
 	};
-	if (typeof i != `object` || !i) {
-		let e = a.find((e) => e.path.length === 0);
-		return e ? l(i, e.type) : i;
+	if (typeof data !== "object" || data === null) {
+		const root = targets.find((t) => t.path.length === 0);
+		if (root) return coerceValue(data, root.type);
+		return data;
 	}
-	let u = [...a].sort((e, t) => e.path.length - t.path.length), d = (e, t, n) => {
-		if (t.length === 0) return n(e);
-		let [r, ...i] = t;
-		if (r === `*`) {
-			if (Array.isArray(e)) {
-				let t = !1, r = e.map((e) => {
-					let r = d(e, i, n);
-					return r !== e && (t = !0), r;
+	const sorted = [...targets].sort((a, b) => a.path.length - b.path.length);
+	const updateAtPath = (current, path, fn) => {
+		if (path.length === 0) return fn(current);
+		const [key, ...rest] = path;
+		if (key === "*") {
+			if (Array.isArray(current)) {
+				let changed = false;
+				const nextArr = current.map((item) => {
+					const nextVal = updateAtPath(item, rest, fn);
+					if (nextVal !== item) changed = true;
+					return nextVal;
 				});
-				return t ? r : e;
+				return changed ? nextArr : current;
 			}
-			return e;
+			return current;
 		}
-		if (!e || typeof e != `object`) return e;
-		if (Array.isArray(e)) {
-			let t = Number(r);
-			if (!Number.isNaN(t) && t >= 0 && t < e.length) {
-				let r = d(e[t], i, n);
-				if (r !== e[t]) {
-					let n = [...e];
-					return n[t] = r, n;
+		if (!current || typeof current !== "object") return current;
+		if (Array.isArray(current)) {
+			const index = Number(key);
+			if (!Number.isNaN(index) && index >= 0 && index < current.length) {
+				const nextVal = updateAtPath(current[index], rest, fn);
+				if (nextVal !== current[index]) {
+					const copy = [...current];
+					copy[index] = nextVal;
+					return copy;
 				}
 			}
-			return e;
+			return current;
 		}
-		if (Object.hasOwn(e, r)) {
-			let t = d(e[r], i, n);
-			if (t !== e[r]) return {
-				...e,
-				[r]: t
+		if (Object.hasOwn(current, key)) {
+			const nextVal = updateAtPath(current[key], rest, fn);
+			if (nextVal !== current[key]) return {
+				...current,
+				[key]: nextVal
 			};
 		}
-		return e;
-	}, f = i;
-	for (let e of u) e.path.length > 0 && (f = d(f, e.path, (t) => l(t, e.type)));
-	return f;
+		return current;
+	};
+	let result = data;
+	for (const t of sorted) if (t.path.length > 0) result = updateAtPath(result, t.path, (val) => coerceValue(val, t.type));
+	return result;
 };
-function c(e, t, n, r) {
-	let a = t ? i(e) : e, c = { ...a }, l = [];
-	if (r) {
-		let e = r();
-		l.push(...e.missingKeys || []), e.hasSchema && (c = s(c, o(e.schema), { arrayFormat: n }));
+/**
+* Prepare an environment record by optionally stripping empty strings and applying coercion.
+*
+* @param env The raw environment variables
+* @param emptyAsUndefined Whether to strip empty string values before processing
+* @param arrayFormat The format to use for array coercion
+* @param getSchema Optional callback that returns a JSON Schema and whether it exists,
+*        used to determine coercion targets. When omitted, no coercion is performed.
+* @returns The processed environment, the coerced environment, and any missing schema keys
+*/
+function coerceEnvironment(env, emptyAsUndefined, arrayFormat, getSchema) {
+	const processedEnv = emptyAsUndefined ? stripEmptyStrings(env) : env;
+	let coercedEnv = { ...processedEnv };
+	const missingKeys = [];
+	if (getSchema) {
+		const result = getSchema();
+		missingKeys.push(...result.missingKeys || []);
+		if (result.hasSchema) coercedEnv = applyCoercion(coercedEnv, findCoercionPaths(result.schema), { arrayFormat });
 	}
 	return {
-		processedEnv: a,
-		coercedEnv: c,
-		missingKeys: l
+		processedEnv,
+		coercedEnv,
+		missingKeys
 	};
 }
-const l = (e, t = 2, { dontDetectNewlines: n = !1 } = {}) => n ? `${` `.repeat(t)}${e}` : e.split(`
-`).map((e) => `${` `.repeat(t)}${e}`).join(`
-`), u = {
-	red: `\x1B[31m`,
-	yellow: `\x1B[33m`,
-	cyan: `\x1B[36m`,
-	reset: `\x1B[0m`
-}, d = () => typeof process < `u` && process.versions != null && process.versions.node != null, f = () => !!(!d() || process.env.NO_COLOR !== void 0 || process.env.CI !== void 0 || process.stdout && !process.stdout.isTTY), p = (e, t) => d() && !f() ? `${u[e]}${t}${u.reset}` : t;
-function m(e) {
-	return e.map((e) => `${p(`yellow`, e.path)} ${e.message.trimStart()}`).join(`
-`);
+/**
+* Indent a string by a given amount
+* @param str - The string to indent
+* @param amt - The amount to indent by, defaults to 2
+* @param options - {@link IndentOptions}
+* @returns The indented string
+*/
+const indent = (str, amt = 2, { dontDetectNewlines = false } = {}) => {
+	if (!dontDetectNewlines) return str.split("\n").map((line) => `${" ".repeat(amt)}${line}`).join("\n");
+	return `${" ".repeat(amt)}${str}`;
+};
+/**
+* Cross-platform text styling utility
+* Uses ANSI colors in Node environments, plain text in browsers
+* Respects NO_COLOR, CI environment variables, and TTY detection
+*/
+const colors = {
+	red: "\x1B[31m",
+	yellow: "\x1B[33m",
+	cyan: "\x1B[36m",
+	reset: "\x1B[0m"
+};
+/**
+* Check if we're in a Node environment (not browser)
+* Checked dynamically to allow for testing with mocked globals
+*/
+const isNode = () => typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+/**
+* Check if colors should be disabled based on environment
+* Respects NO_COLOR, CI environment variables, and TTY detection
+*/
+const shouldDisableColors = () => {
+	if (!isNode()) return true;
+	if (process.env.NO_COLOR !== void 0) return true;
+	if (process.env.CI !== void 0) return true;
+	if (process.stdout && !process.stdout.isTTY) return true;
+	return false;
+};
+/**
+* Style text with color. Uses ANSI codes in Node, plain text in browsers.
+* @param color - The color to apply
+* @param text - The text to style
+* @returns Styled text in Node (if colors enabled), plain text otherwise
+*/
+const styleText = (color, text) => {
+	if (isNode() && !shouldDisableColors()) return `${colors[color]}${text}${colors.reset}`;
+	return text;
+};
+/**
+* Format a list of normalized environment issues into a single styled string.
+*
+* @param issues - The array of normalized issues to format
+* @returns The formatted and styled error report string
+*/
+function formatIssues(issues) {
+	return issues.map((issue) => {
+		return `${styleText("yellow", issue.path)} ${issue.message.trimStart()}`;
+	}).join("\n");
 }
-var h = class extends Error {
-	constructor(e, t = `Errors found while validating environment variables`) {
-		let n = m(e);
-		super(`${p(`red`, t)}\n${l(n)}\n`), this.name = `ArkEnvError`, this.issues = e;
+/**
+* Error thrown when environment variable validation fails.
+*
+* This error extends the native `Error` class and provides formatted error messages
+* that clearly indicate which environment variables are invalid and why.
+*
+* @example
+* ```ts
+* try {
+*   const env = arkenv({
+*     PORT: 'number.port',
+*     HOST: 'string.host',
+*   });
+* } catch (error) {
+*   if (error instanceof ArkEnvError) {
+*     console.error('Environment validation failed:', error.message);
+*   }
+* }
+* ```
+*/
+var ArkEnvError = class extends Error {
+	constructor(issues, message = "Errors found while validating environment variables") {
+		const formattedIssues = formatIssues(issues);
+		super(`${styleText("red", message)}\n${indent(formattedIssues)}\n`);
+		this.name = ARKENV_ERROR_NAME;
+		this.issues = issues;
 	}
 };
-Object.defineProperty(h, `name`, { value: `ArkEnvError` });
-const y = /secret|(_|^)key(_|$)|token|(_|^)password(_|$)|(_|^)pass(_|$)|(_|^)auth(_|$)|jwt|cert|credential|database_url|db_url/i;
-function b(e) {
-	if (e !== void 0) return e;
-	if (typeof process > `u`) return !1;
-	let t = process.env.ARKENV_DEBUG_SECRETS;
-	return t === `true` || t === `1`;
+Object.defineProperty(ArkEnvError, "name", { value: ARKENV_ERROR_NAME });
+/**
+* Regex pattern matching sensitive environment variable names.
+*
+* Matches keywords commonly associated with secrets (e.g. secret, key, token,
+* password, pass, auth, jwt, cert, credential, db_url). Excludes public keys
+* via the `shouldRedact` helper.
+*
+* @see {@link shouldRedact}
+*/
+const SENSITIVE_PATTERN = /secret|(_|^)key(_|$)|token|(_|^)password(_|$)|(_|^)pass(_|$)|(_|^)auth(_|$)|jwt|cert|credential|database_url|db_url/i;
+/**
+* Check if debug secrets mode is enabled.
+*
+* Debug secrets mode can be enabled programmatically via the `debugSecrets` config option,
+* or globally by setting the `ARKENV_DEBUG_SECRETS` environment variable to `"true"` or `"1"`.
+*
+* @param configSecrets Programmatic override option for debugging secrets
+* @returns A boolean indicating if debug secrets mode is active
+*/
+function isDebugSecrets(configSecrets) {
+	if (configSecrets !== void 0) return configSecrets;
+	if (typeof process === "undefined") return false;
+	const val = process.env.ARKENV_DEBUG_SECRETS;
+	return val === "true" || val === "1";
 }
-function x(e) {
-	return y.test(e) && !/public/i.test(e);
+/**
+* Determine if an environment variable path matches sensitive keyword patterns.
+*
+* By default, environment variables that contain sensitive keywords (e.g. 'secret', 'key',
+* 'token', 'password', 'auth', 'jwt', 'cert', 'credential', 'db_url') are flagged for redaction,
+* unless they are explicitly marked as public (e.g., matching 'public').
+*
+* Redaction prevents sensitive values from being logged or printed to the terminal
+* when environment validation fails.
+*
+* @param path The environment variable name/path under validation
+* @returns A boolean indicating if the path is sensitive and should be redacted
+*/
+function shouldRedact(path) {
+	return SENSITIVE_PATTERN.test(path) && !/public/i.test(path);
 }
-function E(e) {
+/**
+* Execute a parser function and return a SafeArkEnvResult.
+*
+* @param parseFn The function that parses the environment variables and might throw an ArkEnvError
+* @returns A SafeArkEnvResult containing either the parsed data or the caught ArkEnvError
+* @internal
+*/
+function safeExecute(parseFn) {
 	try {
 		return {
-			success: !0,
-			data: e()
+			success: true,
+			data: parseFn()
 		};
-	} catch (e) {
-		if (e instanceof h) return {
-			success: !1,
-			issues: e.issues
+	} catch (error) {
+		if (error instanceof ArkEnvError) return {
+			success: false,
+			issues: error.issues
 		};
-		throw e;
+		throw error;
 	}
 }
-function D(e, t, n, r, i, a) {
-	let o = {
-		path: e,
-		message: t,
-		code: n,
-		meta: r ?? {}
+/**
+* Build a normalized {@link EnvIssue}.
+*
+* @param path The dot-separated property path/name of the environment variable
+* @param message The descriptive, user-friendly error message
+* @param code The normalized classification code for the issue
+* @param meta Additional validation metadata and engine codes
+* @param expected The expected type or value shape description
+* @param received The raw value received (redacted in string formatting if sensitive)
+* @returns A fully populated EnvIssue
+* @internal
+*/
+function buildEnvIssue(path, message, code, meta, expected, received) {
+	const issue = {
+		path,
+		message,
+		code,
+		meta: meta ?? {}
 	};
-	return i && (o.expected = i), a !== void 0 && (o.received = a), o;
+	if (expected) issue.expected = expected;
+	if (received !== void 0) issue.received = received;
+	return issue;
 }
-function P(e) {
-	if (!e || typeof e != `object` && typeof e != `function`) return [];
-	if (e.json && typeof e.json == `object` && e.json.domain === `object`) {
-		let t = [];
-		if (Array.isArray(e.json.required)) for (let n of e.json.required) n && typeof n == `object` && `key` in n && t.push(n.key);
-		if (Array.isArray(e.json.optional)) for (let n of e.json.optional) n && typeof n == `object` && `key` in n && t.push(n.key);
-		return t;
+/**
+* Extract the keys from a schema definition.
+* Supports plain objects, ArkType schemas, and Standard Schema validators.
+*
+* @param schema The schema definition to extract keys from
+* @returns An array of extracted key names
+*/
+function getSchemaKeys(schema) {
+	if (!schema || typeof schema !== "object" && typeof schema !== "function") return [];
+	if (schema.json && typeof schema.json === "object" && schema.json.domain === "object") {
+		const keys = [];
+		if (Array.isArray(schema.json.required)) {
+			for (const r of schema.json.required) if (r && typeof r === "object" && "key" in r) keys.push(r.key);
+		}
+		if (Array.isArray(schema.json.optional)) {
+			for (const o of schema.json.optional) if (o && typeof o === "object" && "key" in o) keys.push(o.key);
+		}
+		return keys;
 	}
-	let t = e[`~standard`], n = typeof t?.jsonSchema?.input == `function` && t.jsonSchema.input || typeof e.jsonSchema?.input == `function` && e.jsonSchema.input;
-	if (n) try {
-		let e = n({ target: `draft-07` });
-		if (e && typeof e == `object` && e.properties) return Object.keys(e.properties);
+	const std = schema["~standard"];
+	const jsonSchemaInput = typeof std?.jsonSchema?.input === "function" && std.jsonSchema.input || typeof schema.jsonSchema?.input === "function" && schema.jsonSchema.input;
+	if (jsonSchemaInput) try {
+		const json = jsonSchemaInput({ target: "draft-07" });
+		if (json && typeof json === "object" && json.properties) return Object.keys(json.properties);
 	} catch {}
-	if (typeof e.toJSONSchema == `function`) try {
-		let t = e.toJSONSchema();
-		if (t && typeof t == `object` && t.properties) return Object.keys(t.properties);
+	if (typeof schema.toJSONSchema === "function") try {
+		const json = schema.toJSONSchema();
+		if (json && typeof json === "object" && json.properties) return Object.keys(json.properties);
 	} catch {}
-	if (typeof e.toStandardJSONSchema?.v1 == `function`) try {
-		let t = e.toStandardJSONSchema.v1();
-		if (t && typeof t == `object` && t.properties) return Object.keys(t.properties);
+	if (typeof schema.toStandardJSONSchema?.v1 === "function") try {
+		const json = schema.toStandardJSONSchema.v1();
+		if (json && typeof json === "object" && json.properties) return Object.keys(json.properties);
 	} catch {}
-	return Object.keys(e);
+	return Object.keys(schema);
 }
 
 //#endregion
@@ -296,9 +543,9 @@ function redactMessageWasValue(message, path, debugSecrets) {
 	const valueMatch = message.match(/\(was (.*)\)/);
 	if (!valueMatch?.[1]) return message;
 	const value = valueMatch[1];
-	const displayedValue = !b(debugSecrets) && x(path) ? "[REDACTED]" : value;
+	const displayedValue = !isDebugSecrets(debugSecrets) && shouldRedact(path) ? "[REDACTED]" : value;
 	if (displayedValue.includes("\x1B[")) return message;
-	return message.replace(`(was ${value})`, `(was ${p("cyan", displayedValue)})`);
+	return message.replace(`(was ${value})`, `(was ${styleText("cyan", displayedValue)})`);
 }
 /**
 * Convert ArkType's `ArkErrors` (keyed by path) into a flat `EnvIssue[]`
@@ -323,7 +570,7 @@ function arkErrorsToIssues(errors, config) {
 		message = redactMessageWasValue(message, path, config?.debugSecrets);
 		const code = mapArkTypeCode(error.code);
 		const meta = { ...getArkTypeMeta(error) };
-		return D(path, message, code, meta, error.expected, error.code === "required" ? void 0 : error.data);
+		return buildEnvIssue(path, message, code, meta, error.expected, error.code === "required" ? void 0 : error.data);
 	});
 }
 /**
@@ -349,22 +596,22 @@ function arkErrorsToIssues(errors, config) {
 */
 function parse(def, config) {
 	const { env = process.env, coerce: shouldCoerce = true, onUndeclaredKey = "delete", arrayFormat = "comma", emptyAsUndefined = false } = config;
-	const schemaWithKeys = (typeof def === "function" && "assert" in def ? def : i$1.type.raw(def)).onUndeclaredKey(onUndeclaredKey);
-	const { coercedEnv } = c(env, emptyAsUndefined, arrayFormat, shouldCoerce ? () => {
+	const schemaWithKeys = (typeof def === "function" && "assert" in def ? def : i.type.raw(def)).onUndeclaredKey(onUndeclaredKey);
+	const { coercedEnv } = coerceEnvironment(env, emptyAsUndefined, arrayFormat, shouldCoerce ? () => {
 		return {
 			schema: schemaWithKeys.in.toJsonSchema({ fallback: (ctx) => ctx.base }),
 			hasSchema: true
 		};
 	} : void 0);
 	const validatedEnv = schemaWithKeys(coercedEnv);
-	if (validatedEnv instanceof arktype.ArkErrors) throw new h(arkErrorsToIssues(validatedEnv, config));
+	if (validatedEnv instanceof arktype.ArkErrors) throw new ArkEnvError(arkErrorsToIssues(validatedEnv, config));
 	return validatedEnv;
 }
 
 //#endregion
 //#region src/arkenv.ts
 function arkenv(def, config = {}) {
-	if (config.safe) return E(() => parse(def, config));
+	if (config.safe) return safeExecute(() => parse(def, config));
 	return parse(def, config);
 }
 
@@ -379,20 +626,15 @@ function arkenv(def, config = {}) {
 * See ArkType's docs for the full API:
 * https://arktype.io/docs/type-api
 */
-const type = i$1.type;
-/**
-* ArkEnv's main export, an alias for {@link arkenv}
-*
-* {@link https://arkenv.js.org | ArkEnv} is a typesafe environment variables validator from editor to runtime.
-*/
+const type = i.type;
 var src_default = arkenv;
 
 //#endregion
-exports.ArkEnvError = h;
+exports.ArkEnvError = ArkEnvError;
 exports.arkenv = arkenv;
 exports.default = src_default;
-exports.formatIssues = m;
-exports.getSchemaKeys = P;
+exports.formatIssues = formatIssues;
+exports.getSchemaKeys = getSchemaKeys;
 exports.type = type;
 
 // CJS Interop Shim