@arkenv/standard 1.0.0-alpha.10

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2025 Yam Borodetsky <https://yam.codes/>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+The `apps/dash` maintainer dashboard is licensed separately under
+AGPL-3.0-or-later. See `apps/dash/LICENSE`.

package/dist/bind-arkenv-C8RYZhdK.js

@@ -0,0 +1 @@
+import{arkenv as e}from"./index.js";function t(t){function n(n,r){return e(n,{...r,toJsonSchema:r?.toJsonSchema??t})}return n}export{t};

package/dist/dist-CkiUgOD9.js

@@ -0,0 +1,4 @@
+const e=`ArkEnvError`,t=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},n=e=>e===`true`?!0:e===`false`?!1:e,r=e=>{if(typeof e!=`string`)return e;let t=e.trim();if(t[0]!==`{`&&t[0]!==`[`)return e;try{return JSON.parse(t)}catch{return e}},i=e=>{if(e instanceof Date||typeof e!=`string`||!e.trim())return e;let t=new Date(e);return Number.isNaN(t.getTime())?e:t},a=e=>{let t={};for(let n in e){let r=e[n];r!==``&&(t[n]=r)}return t},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`})}`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`});else if(i===`string`&&`format`in r&&(r.format===`date-time`||r.format===`date`))n.push({path:[...t],type:`date`});else if(i===`object`){if(r.properties&&Object.keys(r.properties).length>0){n.push({path:[...t],type:`object`});for(let e in r.properties)n.push(...o(r.properties[e],[...t,e]))}}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=new Set;return n.filter(e=>{let t=e.path.join(`/`)+`:`+e.type;return a.has(t)?!1:a.add(t)})},s=(e,a,o={})=>{let{arrayFormat:s=`comma`}=o,c=e=>{if(s===`json`)try{return JSON.parse(e)}catch{return e}return e.trim()?e.split(`,`).map(e=>e.trim()):[]},l=(e,a)=>{if(a===`array`&&typeof e==`string`)return c(e);if(a===`object`&&typeof e==`string`)return r(e);if(a===`date`&&typeof e==`string`)return i(e);if(a===`primitive`){if(Array.isArray(e))return e.map(e=>{if(typeof e!=`string`)return e;let r=t(e);return typeof r==`number`?r:n(e)});if(typeof e!=`string`)return e;let r=t(e);return typeof r==`number`?r:n(e)}return e};if(typeof e!=`object`||!e){let t=a.find(e=>e.path.length===0);return t?l(e,t.type):e}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});return t?r:e}return e}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}}return e}if(Object.hasOwn(e,r)){let t=d(e[r],i,n);if(t!==e[r])return{...e,[r]:t}}return e},f=e;for(let e of u)e.path.length>0&&(f=d(f,e.path,t=>l(t,e.type)));return f};function c(e,t,n,r){let i=t?a(e):e,c={...i},l=[];if(r){let e=r();l.push(...e.missingKeys||[]),e.hasSchema&&(c=s(c,o(e.schema),{arrayFormat:n}))}return{processedEnv:i,coercedEnv:c,missingKeys:l}}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(`
+`)}var h=class extends Error{constructor(t,n=`Errors found while validating environment variables`){let r=m(t);super(`${p(`red`,n)}\n${l(r)}\n`),this.name=e,this.issues=t}};Object.defineProperty(h,`name`,{value:e});function g(e,t){if(typeof t==`string`)throw new h([{path:e,message:`ArkType DSL strings are not supported in "standard" mode. Use a Standard Schema validator (e.g., Zod, Valibot) or import from "arkenv" for ArkType schemas.`,code:`INVALID_SCHEMA`}])}function _(e,t){let n=t&&typeof t==`object`&&`~standard`in t&&t[`~standard`];if(!n||typeof n!=`object`||!(`validate`in n)||typeof n.validate!=`function`)throw new h([{path:e,message:`Invalid validator: expected a Standard Schema 1.0 validator (must have "~standard" property). Import from "arkenv" to use ArkType schemas.`,code:`INVALID_SCHEMA`}])}function v(e){if(!e||typeof e!=`object`||Array.isArray(e))throw new h([{path:``,message:`Invalid schema: expected an object mapping in "standard" mode.`,code:`INVALID_SCHEMA`}])}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`}function x(e){return y.test(e)&&!/public/i.test(e)}function S(e,t,n){let r=b(n?.debugSecrets);if(e===void 0)return`missing`;if(e===null)return`null`;if(!r&&x(t))return`[REDACTED]`;if(typeof e==`string`)return JSON.stringify(e);if(typeof e==`number`||typeof e==`boolean`||typeof e==`bigint`)return String(e);if(typeof e==`symbol`)return e.toString();if(typeof e==`function`)return`[Function]`;if(e&&typeof e==`object`)try{if(Array.isArray(e)){let r=e.slice(0,3).map(e=>S(e,t,n));return e.length>3&&r.push(`...(+${e.length-3} more)`),`[${r.join(`, `)}]`}let r=Object.keys(e),i=r.slice(0,3).map(r=>`${r}: ${S(e[r],t,n)}`);return r.length>3&&i.push(`...(+${r.length-3} more)`),`{ ${i.join(`, `)} }`}catch{return Object.prototype.toString.call(e)}return String(e)}const C={too_small:`VALUE_TOO_SMALL`,too_big:`VALUE_TOO_LARGE`,invalid_string:`INVALID_FORMAT`,invalid_date:`INVALID_FORMAT`,custom:`INVALID_FORMAT`};function w(e,t,n){let r=t.toLowerCase();return e===`invalid_type`&&(n===void 0||n===`undefined`)||r===`required`?`MISSING_VARIABLE`:e in C?C[e]:/regex|pattern|match/.test(r)?`PATTERN_MISMATCH`:`INVALID_TYPE`}function T(e){let t=e.minimum??e.min,n=e.maximum??e.max;return{...typeof t==`number`?{min:t}:{},...typeof n==`number`?{max:n}:{}}}function E(e){try{return{success:!0,data:e()}}catch(e){if(e instanceof h)return{success:!1,issues:e.issues};throw e}}function D(e,t,n,r,i,a){let o={path:e,message:t,code:n,meta:r??{}};return i&&(o.expected=i),a!==void 0&&(o.received=a),o}function O(e,t,n,r,i,a){if(t===`MISSING_VARIABLE`)return n?`must be ${n} (was missing)`:`is required`;if(e.includes(`(was `))return e;let o=`(was ${p(`cyan`,!b(a?.debugSecrets)&&x(i)?`[REDACTED]`:S(r,i,a))})`;return n&&!e.includes(`Expected`)?`must be ${n} ${o}`:`${e} ${o}`}const k=[`draft-07`,`draft-2020-12`];function A(e){return Object.prototype.toString.call(e)===`[object Object]`}function j(e){let t=`converter returned a non-schema`;for(let n of k)try{let r=e({target:n});if(A(r))return{ok:!0,schema:r};t=`converter returned a non-schema`}catch(e){t=e instanceof Error?e.message:String(e)}return{ok:!1,detail:t}}function M(e,t){throw new h([D(e,`JSON Schema conversion failed for '${e}': ${t}`,`INVALID_SCHEMA`)])}function N(e,t){let n={type:`object`,properties:{}},r=!1,i=[];for(let a in e){let o=e[a];if(!o){i.push(a);continue}let s=o[`~standard`];if(typeof s?.jsonSchema?.input==`function`){let e=j(s.jsonSchema.input);if(e.ok){n.properties[a]=e.schema,r=!0;continue}M(a,e.detail)}if(typeof o.jsonSchema?.input==`function`){let e=j(o.jsonSchema.input);if(e.ok){n.properties[a]=e.schema,r=!0;continue}M(a,e.detail)}if(typeof o.toJSONSchema==`function`)try{let e=o.toJSONSchema();if(e){n.properties[a]=e,r=!0;continue}}catch{}if(typeof o.toStandardJSONSchema?.v1==`function`)try{let e=o.toStandardJSONSchema.v1();if(e){n.properties[a]=e,r=!0;continue}}catch{}if(t){let e;try{e=t(o)}catch(e){throw new h([D(a,`toJsonSchema failed for '${a}': ${e instanceof Error?e.message:String(e)}`,`INVALID_SCHEMA`)])}if(!e){i.push(a);continue}if(!A(e))throw new h([D(a,`toJsonSchema must return a plain object or undefined for '${a}'.`,`INVALID_SCHEMA`)]);n.properties[a]=e,r=!0;continue}i.push(a)}return{jsonSchema:n,hasJsonSchema:r,missingKeys:i}}function P(e){return typeof e==`object`&&e&&`key`in e?String(e.key):String(e)}function F(e,t){return!t||t.length===0?e:[e,...t.map(P)].join(`.`)}function I(e,t){let n=e,r;try{let i=e,a=e.trim();if(a[0]===`{`||a[0]===`[`)try{i=JSON.parse(e)}catch(e){r=`[Unparseable JSON: ${e.message}]`}if(!r){for(let e of t)i=i?.[P(e)];n=i}}catch(e){r=`[Traversal error: ${e.message}]`}return{receivedVal:n,traversalError:r}}function L(e,t){let{env:n=process.env,onUndeclaredKey:r=`delete`,coerce:i=!0,arrayFormat:a=`comma`,emptyAsUndefined:o=!1,toJsonSchema:s}=t,l={},u=[],{processedEnv:d,coercedEnv:f,missingKeys:p}=c(n,o,a,i?()=>{let{jsonSchema:t,hasJsonSchema:n,missingKeys:r}=N(e,s);return{schema:t,hasSchema:n,missingKeys:r}}:void 0),m=new Set(Object.keys(d));for(let n in e){let r=e[n],a=f[n];if(!r||typeof r!=`object`||!(`~standard`in r))throw new h([D(n,`Invalid schema: expected a Standard Schema 1.0 validator (e.g. Zod, Valibot) in 'standard' mode.`,`INVALID_SCHEMA`)]);let o=r[`~standard`].validate(a);if(o instanceof Promise)throw new h([D(n,`Async validation is not supported. ArkEnv is synchronous.`,`INVALID_SCHEMA`)]);if(o.issues)for(let e of o.issues){let r=F(n,e.path),a,o;if(n in d){let t=d[n];if(typeof t==`string`&&e.path?.length){let n=I(t,e.path);a=n.receivedVal,o=n.traversalError}else a=t}else a=e.received;let s=w(e.code||`invalid_type`,e.message||``,a),c=e.expected||void 0,l={...T(e)},f=e;f.validation!==void 0&&(l.validation=f.validation),o!==void 0&&(l.traversalError=o);let m=O(e.message||``,s,c,a,r,t);i&&p.includes(n)&&(m+=` (Hint: coercion is enabled by default, but the validator for '${n}' lacks Standard JSON Schema support.)`),u.push(D(r,m,s,l,c,a))}else l[n]=o.value;m.delete(n)}if(r!==`delete`)for(let e of m)r===`reject`?u.push(D(e,`Undeclared key`,`UNDECLARED_KEY`)):r===`ignore`&&(l[e]=f[e]);if(u.length>0)throw new h(u);return l}function R(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}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)}catch{}if(typeof e.toJSONSchema==`function`)try{let t=e.toJSONSchema();if(t&&typeof t==`object`&&t.properties)return Object.keys(t.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)}catch{}return Object.keys(e)}const z=Symbol.for(`arkenv.schemaCapture.v1`);function B(){let e=globalThis;return e[z]||(e[z]={capturing:!1,definitions:[]}),e[z]}function V(){return B().capturing}function H(e){let t=B();t.capturing&&t.definitions.push(e)}export{m as a,L as c,v as i,H as l,g as n,R as o,_ as r,V as s,h as t,E as u};

package/dist/index-CHZF-Mlg.d.ts

@@ -0,0 +1,630 @@
+//#region ../internal/types/dist/standard-schema.d.ts
+/**
+ * @see https://github.com/standard-schema/standard-schema/tree/3130ce43fdd848d9ab49dbb0458d04f18459961c/packages/spec
+ *
+ * Copied from standard-schema (MIT License)
+ * Copyright (c) 2024 Colin McDannell
+ */
+/**
+ * The Standard Typed interface. This is a base type extended by other specs.
+ */
+interface StandardTypedV1$1<Input = unknown, Output = Input> {
+  /**
+   * The Standard properties.
+   */
+  readonly "~standard": StandardTypedV1$1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1$1 {
+  /**
+   * The Standard Typed properties interface.
+   */
+  interface Props<Input = unknown, Output = Input> {
+    /**
+     * The version number of the standard.
+     */
+    readonly version: 1;
+    /**
+     * The vendor name of the schema library.
+     */
+    readonly vendor: string;
+    /**
+     * Inferred types associated with the schema.
+     */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /**
+   * The Standard Typed types interface.
+   */
+  interface Types<Input = unknown, Output = Input> {
+    /**
+     * The input type of the schema.
+     */
+    readonly input: Input;
+    /**
+     * The output type of the schema.
+     */
+    readonly output: Output;
+  }
+  /**
+   * Infers the input type of a Standard Typed.
+   */
+  type InferInput<Schema extends StandardTypedV1$1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /**
+   * Infers the output type of a Standard Typed.
+   */
+  type InferOutput<Schema extends StandardTypedV1$1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/**
+ * The Standard Schema interface.
+ */
+interface StandardSchemaV1$1<Input = unknown, Output = Input> {
+  /**
+   * The Standard Schema properties.
+   */
+  readonly "~standard": StandardSchemaV1$1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1$1 {
+  /**
+   * The Standard Schema properties interface.
+   */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1$1.Props<Input, Output> {
+    /**
+     * Validates unknown input values.
+     */
+    readonly validate: (value: unknown, options?: StandardSchemaV1$1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /**
+   * The result interface of the validate function.
+   */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /**
+   * The result interface if validation succeeds.
+   */
+  interface SuccessResult<Output> {
+    /**
+     * The typed output value.
+     */
+    readonly value: Output;
+    /**
+     * A falsy value for `issues` indicates success.
+     */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /**
+     * Explicit support for additional vendor-specific parameters, if needed.
+     */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /**
+   * The result interface if validation fails.
+   */
+  interface FailureResult {
+    /**
+     * The issues of failed validation.
+     */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /**
+   * The issue interface of the failure output.
+   */
+  interface Issue {
+    /**
+     * The error message of the issue.
+     */
+    readonly message: string;
+    /**
+     * The path of the issue, if any.
+     */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /**
+   * The path segment interface of the issue.
+   */
+  interface PathSegment {
+    /**
+     * The key representing a path segment.
+     */
+    readonly key: PropertyKey;
+  }
+  /**
+   * The Standard types interface.
+   */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1$1.Types<Input, Output> {}
+  /**
+   * Infers the input type of a Standard.
+   */
+  type InferInput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferInput<Schema>;
+  /**
+   * Infers the output type of a Standard.
+   */
+  type InferOutput<Schema extends StandardTypedV1$1> = StandardTypedV1$1.InferOutput<Schema>;
+}
+//#endregion
+//#region ../internal/utils/dist/index.d.ts
+//#endregion
+//#region ../types/dist/standard-schema.d.ts
+/**
+ * @see https://github.com/standard-schema/standard-schema/tree/3130ce43fdd848d9ab49dbb0458d04f18459961c/packages/spec
+ *
+ * Copied from standard-schema (MIT License)
+ * Copyright (c) 2024 Colin McDannell
+ */
+/**
+ * The Standard Typed interface. This is a base type extended by other specs.
+ */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /**
+   * The Standard properties.
+   */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /**
+   * The Standard Typed properties interface.
+   */
+  interface Props<Input = unknown, Output = Input> {
+    /**
+     * The version number of the standard.
+     */
+    readonly version: 1;
+    /**
+     * The vendor name of the schema library.
+     */
+    readonly vendor: string;
+    /**
+     * Inferred types associated with the schema.
+     */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /**
+   * The Standard Typed types interface.
+   */
+  interface Types<Input = unknown, Output = Input> {
+    /**
+     * The input type of the schema.
+     */
+    readonly input: Input;
+    /**
+     * The output type of the schema.
+     */
+    readonly output: Output;
+  }
+  /**
+   * Infers the input type of a Standard Typed.
+   */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /**
+   * Infers the output type of a Standard Typed.
+   */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/**
+ * The Standard Schema interface.
+ */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /**
+   * The Standard Schema properties.
+   */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /**
+   * The Standard Schema properties interface.
+   */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /**
+     * Validates unknown input values.
+     */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /**
+   * The result interface of the validate function.
+   */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /**
+   * The result interface if validation succeeds.
+   */
+  interface SuccessResult<Output> {
+    /**
+     * The typed output value.
+     */
+    readonly value: Output;
+    /**
+     * A falsy value for `issues` indicates success.
+     */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /**
+     * Explicit support for additional vendor-specific parameters, if needed.
+     */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /**
+   * The result interface if validation fails.
+   */
+  interface FailureResult {
+    /**
+     * The issues of failed validation.
+     */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /**
+   * The issue interface of the failure output.
+   */
+  interface Issue {
+    /**
+     * The error message of the issue.
+     */
+    readonly message: string;
+    /**
+     * The path of the issue, if any.
+     */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /**
+   * The path segment interface of the issue.
+   */
+  interface PathSegment {
+    /**
+     * The key representing a path segment.
+     */
+    readonly key: PropertyKey;
+  }
+  /**
+   * The Standard types interface.
+   */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /**
+   * Infers the input type of a Standard.
+   */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /**
+   * Infers the output type of a Standard.
+   */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+} //#endregion
+//#region src/coercion/environment.d.ts
+/**
+ * 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
+ */
+//#endregion
+//#region src/core.d.ts
+/**
+ * Machine-readable classification codes for environment validation issues.
+ */
+type EnvIssueCode =
+/**
+ * The environment variable is required but was not provided, and has no default value.
+ */
+"MISSING_VARIABLE"
+/**
+ * The variable value failed a type assertion (e.g., expected a number or boolean but received a string).
+ */
+| "INVALID_TYPE"
+/**
+ * The variable value falls below the minimum allowed numeric limit or string/array length constraint.
+ */
+| "VALUE_TOO_SMALL"
+/**
+ * The variable value exceeds the maximum allowed numeric limit or string/array length constraint.
+ */
+| "VALUE_TOO_LARGE"
+/**
+ * The variable value did not match the specified regular expression (regex) pattern constraint.
+ */
+| "PATTERN_MISMATCH"
+/**
+ * The variable value is not in a valid format (e.g., failed email or UUID format validation).
+ */
+| "INVALID_FORMAT"
+/**
+ * An undeclared key was found in the environment, and the schema config is set to reject undeclared keys.
+ */
+| "UNDECLARED_KEY"
+/**
+ * The provided validation schema definition itself is malformed or invalid.
+ */
+| "INVALID_SCHEMA"
+/**
+ * A validation error was triggered by a custom validator function or inline pipe logic.
+ */
+| "CUSTOM";
+/**
+ * Metadata associated with an environment validation issue.
+ */
+type EnvIssueMeta = {
+  /**
+   * The minimum expected boundary for numeric/string length constraints
+   */
+  min?: number;
+  /**
+   * The maximum expected boundary for numeric/string length constraints
+   */
+  max?: number;
+  /**
+   * Additional validation pattern/specifier details
+   */
+  validation?: string;
+  /**
+   * Any custom constraint descriptions
+   */
+  constraint?: string;
+  /**
+   * Traversal error occurred during JSON-parsing of the environment variable
+   */
+  traversalError?: string;
+};
+/**
+ * Normalized validation issue representing a failure on a specific environment variable.
+ */
+type EnvIssue = {
+  /**
+   * The dot-separated property path/name of the environment variable
+   */
+  path: string;
+  /**
+   * The descriptive, user-friendly error message
+   */
+  message: string;
+  /**
+   * The normalized classification code for the issue
+   */
+  code: EnvIssueCode;
+  /**
+   * The expected type or value shape description
+   */
+  expected?: string;
+  /**
+   * The raw value received (redacted in string formatting if sensitive)
+   */
+  received?: unknown;
+  /**
+   * Additional validation metadata
+   */
+  meta?: EnvIssueMeta;
+};
+/**
+ * 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
+ */
+declare function formatIssues(issues: EnvIssue[]): string;
+/**
+ * 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);
+ *   }
+ * }
+ * ```
+ */
+declare class ArkEnvError extends Error {
+  /**
+   * The list of normalized issues that caused the validation failure
+   */
+  readonly issues: EnvIssue[];
+  constructor(issues: EnvIssue[], message?: string);
+}
+/**
+ * Result of a non-throwing arkenv parse operation.
+ */
+type SafeArkEnvResult<T> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  issues: readonly EnvIssue[];
+}; //#endregion
+//#region src/guards.d.ts
+/**
+ * Throws if the given value is a string (ArkType DSL) in standard mode.
+ * @internal
+ */
+//#endregion
+//#region src/parse-standard.d.ts
+/**
+ * Configuration options for {@link parseStandard}.
+ */
+type ParseStandardConfig = {
+  /**
+   * The environment variables to parse. Defaults to `process.env`.
+   *
+   * All values must be strings (or `undefined`) to match `process.env` semantics.
+   */
+  env?: Record<string, string | undefined>;
+  /**
+   * Control how ArkEnv handles environment variables that are not defined in your schema.
+   *
+   * Defaults to `'delete'` so the output object only contains keys you've declared.
+   *
+   * - `delete` (default): Undeclared keys are allowed on input but stripped from the output.
+   * - `ignore`: Undeclared keys are allowed and preserved in the output.
+   * - `reject`: Undeclared keys will cause validation to fail.
+   *
+   * @default "delete"
+   */
+  onUndeclaredKey?: "ignore" | "delete" | "reject";
+  /**
+   * Whether to bypass secret redaction and print raw sensitive values during debugging.
+   * Defaults to checking `process.env.ARKENV_DEBUG_SECRETS === "true"` or `"1"`.
+   */
+  debugSecrets?: boolean;
+  /**
+   * Whether to perform best-effort coercion on the environment variables.
+   * Coercion prefers validators that expose Standard JSON Schema on the value
+   * itself (e.g. Zod). For converters that live outside the schema (e.g. Valibot
+   * via `@valibot/to-json-schema`, Zod Mini via `z.toJSONSchema`, or Zod v3 via
+   * `zod-to-json-schema`), pass {@link toJsonSchema}.
+   *
+   * @see https://standard-schema.dev
+   * @default true
+   */
+  coerce?: boolean;
+  /**
+   * Optional fallback that converts a Standard Schema validator to JSON Schema
+   * for ArkEnv pre-coercion when a key has no Standard JSON Schema on the value.
+   *
+   * Called per key only in that case. Not called when omitted, when `coerce` is
+   * `false`, or when JSON Schema was already read from the value.
+   *
+   * - Return a plain object to use as that key's JSON Schema.
+   * - Return `undefined` to skip coercion for that key only.
+   * - Throwing or returning a non-plain object fails the parse with
+   *   {@link ArkEnvError} for that key (`INVALID_SCHEMA`).
+   *
+   * Typed as {@link StandardSchemaV1}. Host converters (Valibot, Zod Mini,
+   * Zod v3 via `zod-to-json-schema`) do not accept that type — assert at the
+   * converter call (`as v.GenericSchema`, `as z.ZodMiniType`,
+   * `as z.ZodTypeAny`). Same assertion for a single-library map and a hybrid
+   * with classic Zod (Zod never reaches this callback at runtime).
+   *
+   * @example Valibot wiring
+   * ```ts
+   * import { toJsonSchema } from "@valibot/to-json-schema";
+   * import * as v from "valibot";
+   *
+   * arkenv(
+   *   { PORT: v.number() },
+   *   {
+   *     toJsonSchema: (schema) =>
+   *       toJsonSchema(schema as v.GenericSchema, {
+   *         typeMode: "input",
+   *         target: "draft-07",
+   *       }),
+   *   },
+   * );
+   * ```
+   *
+   * @example Zod v3 wiring
+   * ```ts
+   * import { z } from "zod/v3";
+   * import { zodToJsonSchema } from "zod-to-json-schema";
+   *
+   * arkenv(
+   *   { PORT: z.number() },
+   *   {
+   *     toJsonSchema: (schema) =>
+   *       zodToJsonSchema(schema as z.ZodTypeAny, {
+   *         $refStrategy: "none",
+   *       }),
+   *   },
+   * );
+   * ```
+   */
+  toJsonSchema?: (schema: StandardSchemaV1) => object | undefined;
+  /**
+   * The format to use for array parsing when coercion is enabled.
+   *
+   * - `comma` (default): Strings are split by comma and trimmed.
+   * - `json`: Strings are parsed as JSON.
+   *
+   * @default "comma"
+   */
+  arrayFormat?: "comma" | "json";
+  /**
+   * Whether to treat empty strings (`""`) as `undefined` before validation.
+   *
+   * When enabled, an environment variable set to an empty value (e.g. `PORT=`)
+   * will be treated as if it were missing, allowing defaults to apply and
+   * preventing validation errors for numeric or boolean types.
+   *
+   * @default false
+   */
+  emptyAsUndefined?: boolean;
+  /**
+   * Reserved for call-site compat. Pass `false` or omit.
+   * Use `arkenv` from `@arkenv/standard/safe` (or `@arkenv/core/safe`) instead of `{ safe: true }`.
+   *
+   * @default false
+   */
+  safe?: false;
+};
+/**
+ * Parse and validate environment variables using Standard Schema 1.0 validators.
+ *
+ * @param def An object mapping environment variable keys to Standard Schema 1.0 validators
+ * @param config Parsing options, including environment source, undeclared key handling, and coercion config
+ * @returns The parsed and validated environment variables
+ * @throws An ArkEnvError if validation fails
+ */
+//#endregion
+//#region src/schema.d.ts
+/**
+ * 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
+ */
+declare function getSchemaKeys(schema: any): string[]; //#endregion
+//#region src/schema-capture.d.ts
+/**
+ * Start recording `arkenv()` schema arguments instead of validating the environment.
+ *
+ * CLI-supporting API: tools such as the ArkEnv CLI use this to inspect a user's
+ * schema module without requiring `process.env` to be populated.
+ */
+//#endregion
+//#region src/index.d.ts
+/**
+ * Configuration options for `arkenv` from `@arkenv/standard`.
+ *
+ * `safe` is reserved for call-site compat — pass `false` or omit. Use
+ * `arkenv` from `@arkenv/standard/safe` for a result object.
+ */
+type StandardEnvConfig = Omit<ParseStandardConfig, "safe"> & {
+  /**
+   * Reserved for call-site compat. Pass `false` or omit.
+   * Use `arkenv` from `@arkenv/standard/safe` instead of `{ safe: true }`.
+   *
+   * @default false
+   */
+  safe?: false;
+};
+type StandardEnvOutput<T extends Record<string, StandardSchemaV1$1>> = { [K in keyof T]: StandardSchemaV1$1.InferOutput<T[K]> };
+/**
+ * Parse and validate environment variables using Standard Schema 1.0 validators (e.g. Zod, Valibot).
+ *
+ * This entry is ArkType-free - ArkType is never imported, even transitively.
+ * Use this when your project must not depend on ArkType.
+ *
+ * @param def An object mapping variable names to Standard Schema validators
+ * @param config Optional configuration
+ * @returns The validated environment variables, or a value-less stub when schema capture is active
+ * @throws An {@link ArkEnvError} if validation fails
+ *
+ * @example
+ * ```ts
+ * import arkenv from "@arkenv/standard";
+ * import * as z from "zod";
+ *
+ * const env = arkenv({
+ *   PORT: z.number(),
+ *   HOST: z.string(),
+ * });
+ * ```
+ */
+declare function arkenv<const T extends Record<string, StandardSchemaV1$1>>(def: T, config?: StandardEnvConfig): StandardEnvOutput<T>;
+//#endregion
+export { SafeArkEnvResult as a, StandardSchemaV1$1 as c, EnvIssue as i, arkenv as n, formatIssues as o, ArkEnvError as r, getSchemaKeys as s, StandardEnvConfig as t };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { a as SafeArkEnvResult, i as EnvIssue, n as arkenv, o as formatIssues, r as ArkEnvError, s as getSchemaKeys, t as StandardEnvConfig } from "./index-CHZF-Mlg.js";
+export { ArkEnvError, EnvIssue, SafeArkEnvResult, StandardEnvConfig, arkenv, arkenv as default, formatIssues, getSchemaKeys };

package/dist/index.js

@@ -0,0 +1 @@
+import{a as e,c as t,i as n,l as r,n as i,o as a,r as o,s,t as c}from"./dist-CkiUgOD9.js";function l(e,a){let c=a??{};n(e);for(let t in e){let n=e[t];i(t,n),o(t,n)}return s()?(r(e),{}):t(e,c)}export{c as ArkEnvError,l as arkenv,l as default,e as formatIssues,a as getSchemaKeys};

package/dist/safe.d.ts

@@ -0,0 +1,35 @@
+import { a as SafeArkEnvResult, c as StandardSchemaV1, t as StandardEnvConfig } from "./index-CHZF-Mlg.js";
+
+//#region src/safe.d.ts
+type SafeStandardEnvConfig = Omit<StandardEnvConfig, "safe">;
+type StandardEnvOutput<T extends Record<string, StandardSchemaV1>> = { [K in keyof T]: StandardSchemaV1.InferOutput<T[K]> };
+/**
+ * Parse environment variables with Standard Schema validators and return a
+ * result object instead of throwing.
+ *
+ * While CLI schema capture is active, records `def` and returns a stub
+ * `{ success: true, data: {} }` without validating the environment — same
+ * handshake as `arkenv()` from `@arkenv/standard`.
+ *
+ * @param def An object mapping variable names to Standard Schema validators
+ * @param config Optional configuration
+ * @returns `{ success: true, data }` or `{ success: false, issues }`
+ *
+ * @example
+ * ```ts
+ * import arkenv from "@arkenv/standard/safe";
+ * import * as z from "zod";
+ *
+ * const result = arkenv(
+ *   { PORT: z.coerce.number() },
+ *   { env: { PORT: "invalid" } },
+ * );
+ *
+ * if (!result.success) {
+ *   console.error(result.issues);
+ * }
+ * ```
+ */
+declare function arkenv<const T extends Record<string, StandardSchemaV1>>(def: T, config?: SafeStandardEnvConfig): SafeArkEnvResult<StandardEnvOutput<T>>;
+//#endregion
+export { type SafeArkEnvResult, arkenv, arkenv as default };

package/dist/safe.js

@@ -0,0 +1 @@
+import{c as e,i as t,l as n,n as r,r as i,s as a,u as o}from"./dist-CkiUgOD9.js";function s(s,c){let l=c??{};t(s);for(let e in s){let t=s[e];r(e,t),i(e,t)}return a()?(n(s),{success:!0,data:{}}):o(()=>e(s,l))}export{s as arkenv,s as default};

package/dist/valibot.d.ts

@@ -0,0 +1,29 @@
+import { a as SafeArkEnvResult, i as EnvIssue, n as arkenv$1, o as formatIssues, r as ArkEnvError, s as getSchemaKeys, t as StandardEnvConfig } from "./index-CHZF-Mlg.js";
+
+//#region src/valibot.d.ts
+/**
+ * Parse and validate environment variables with Valibot.
+ *
+ * Pre-binds `@valibot/to-json-schema` (`typeMode: "input"`, `target: "draft-07"`)
+ * so `v.number()` and `v.boolean()` coerce without a manual `toJsonSchema`
+ * callback. Install `@valibot/to-json-schema` alongside `valibot`.
+ *
+ * @param def An object mapping variable names to Valibot schemas
+ * @param config Optional configuration. Pass `toJsonSchema` to override the bound converter
+ * @returns The validated environment variables
+ * @throws An {@link ArkEnvError} if validation fails
+ *
+ * @example
+ * ```ts
+ * import { arkenv } from "@arkenv/standard/valibot";
+ * import * as v from "valibot";
+ *
+ * const env = arkenv({
+ *   PORT: v.optional(v.number(), 3000),
+ *   DEBUG: v.optional(v.boolean(), false),
+ * });
+ * ```
+ */
+declare const arkenv: typeof arkenv$1;
+//#endregion
+export { ArkEnvError, type EnvIssue, type SafeArkEnvResult, type StandardEnvConfig, arkenv, arkenv as default, formatIssues, getSchemaKeys };

package/dist/valibot.js

@@ -0,0 +1 @@
+import{a as e,o as t,t as n}from"./dist-CkiUgOD9.js";import"./index.js";import{t as r}from"./bind-arkenv-C8RYZhdK.js";import{toJsonSchema as i}from"@valibot/to-json-schema";const a=r(e=>i(e,{typeMode:`input`,target:`draft-07`}));export{n as ArkEnvError,a as arkenv,a as default,e as formatIssues,t as getSchemaKeys};

package/dist/zod-mini.d.ts

@@ -0,0 +1,30 @@
+import { a as SafeArkEnvResult, i as EnvIssue, n as arkenv$1, o as formatIssues, r as ArkEnvError, s as getSchemaKeys, t as StandardEnvConfig } from "./index-CHZF-Mlg.js";
+
+//#region src/zod-mini.d.ts
+/**
+ * Parse and validate environment variables with Zod Mini.
+ *
+ * Pre-binds `zod/mini`'s `toJSONSchema` helper (`io: "input"`, `target: "draft-07"`)
+ * so Mini `z.number()` and `z.boolean()` coerce without a manual `toJsonSchema`
+ * callback. Install `zod` (optional peer) and import Mini from `zod/mini`.
+ * Classic Zod should keep using `@arkenv/standard`.
+ *
+ * @param def An object mapping variable names to Zod Mini schemas
+ * @param config Optional configuration. Pass `toJsonSchema` to override the bound converter
+ * @returns The validated environment variables
+ * @throws An {@link ArkEnvError} if validation fails
+ *
+ * @example
+ * ```ts
+ * import { arkenv } from "@arkenv/standard/zod-mini";
+ * import * as z from "zod/mini";
+ *
+ * const env = arkenv({
+ *   PORT: z.number(),
+ *   DEBUG: z.boolean(),
+ * });
+ * ```
+ */
+declare const arkenv: typeof arkenv$1;
+//#endregion
+export { ArkEnvError, type EnvIssue, type SafeArkEnvResult, type StandardEnvConfig, arkenv, arkenv as default, formatIssues, getSchemaKeys };

package/dist/zod-mini.js

@@ -0,0 +1 @@
+import{a as e,o as t,t as n}from"./dist-CkiUgOD9.js";import"./index.js";import{t as r}from"./bind-arkenv-C8RYZhdK.js";import{toJSONSchema as i}from"zod/mini";const a=r(e=>i(e,{io:`input`,target:`draft-07`}));export{n as ArkEnvError,a as arkenv,a as default,e as formatIssues,t as getSchemaKeys};

package/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "@arkenv/standard",
+  "type": "module",
+  "version": "1.0.0-alpha.10",
+  "description": "Dependency-free, typesafe environment variables validation based on Standard Schema",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./safe": {
+      "types": "./dist/safe.d.ts",
+      "import": "./dist/safe.js",
+      "default": "./dist/safe.js"
+    },
+    "./valibot": {
+      "types": "./dist/valibot.d.ts",
+      "import": "./dist/valibot.js",
+      "default": "./dist/valibot.js"
+    },
+    "./zod-mini": {
+      "types": "./dist/zod-mini.d.ts",
+      "import": "./dist/zod-mini.js",
+      "default": "./dist/zod-mini.js"
+    }
+  },
+  "peerDependencies": {
+    "@valibot/to-json-schema": "^1.0.0",
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@valibot/to-json-schema": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "env",
+    "environment-variables",
+    "environment",
+    "variables",
+    "dotenv",
+    "config",
+    "validation",
+    "typesafe",
+    "standard-schema",
+    "zod",
+    "valibot"
+  ],
+  "license": "MIT",
+  "homepage": "https://arkenv.js.org",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yamcodes/arkenv.git"
+  },
+  "bugs": "https://github.com/yamcodes/arkenv/labels/arkenv",
+  "author": "Yam Borodetsky <yam@yam.codes>",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@size-limit/esbuild-why": "12.1.0",
+    "@size-limit/preset-small-lib": "12.1.0",
+    "@types/node": "24.12.2",
+    "@valibot/to-json-schema": "1.6.0",
+    "rimraf": "6.1.3",
+    "size-limit": "12.1.0",
+    "tsdown": "0.21.10",
+    "typescript": "6.0.3",
+    "valibot": "1.3.1",
+    "vitest": "4.1.5",
+    "zod": "4.4.1",
+    "zod-to-json-schema": "3.25.2",
+    "@repo/utils": "0.1.3",
+    "@repo/types": "0.1.0"
+  },
+  "size-limit": [
+    {
+      "name": "@arkenv/standard",
+      "path": "dist/index.js",
+      "limit": "3.9 kB",
+      "import": "*"
+    },
+    {
+      "name": "@arkenv/standard/valibot",
+      "path": "dist/valibot.js",
+      "limit": "4.5 kB",
+      "import": "*",
+      "ignore": [
+        "@valibot/to-json-schema"
+      ]
+    },
+    {
+      "name": "@arkenv/standard/zod-mini",
+      "path": "dist/zod-mini.js",
+      "limit": "4.5 kB",
+      "import": "*",
+      "ignore": [
+        "zod",
+        "zod/mini"
+      ]
+    }
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "size": "size-limit --json > .size-limit.json",
+    "test": "vitest",
+    "test:once": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "clean": "rimraf dist node_modules",
+    "fix": "pnpm -w run fix"
+  }
+}