enwow 0.0.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-PRESENT blasdfaa <https://github.com/blasdfaa>
+
+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.

package/README.md

@@ -0,0 +1,252 @@
+# enwow
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![bundle][bundle-src]][bundle-href]
+[![License][license-src]][license-href]
+
+Cross-platform environment variables loader and validator with [Standard Schema](https://standardschema.dev/) support.
+
+## Features
+
+- 🚀 **Cross-platform** - Works on Node.js, Bun, and Deno
+- ✅ **Standard Schema** - Compatible with Zod, Valibot, ArkType, and more
+- 📁 **.env file loading** - With proper file priority support
+- 🔒 **Type-safe** - Full TypeScript support with type inference
+- 🪶 **Lightweight** - Minimal dependencies
+
+## Installation
+
+```sh
+npm install enwow
+# or
+pnpm add enwow
+# or
+yarn add enwow
+```
+
+You'll also need a schema library that supports Standard Schema:
+
+```sh
+npm install zod
+# or
+npm install valibot
+# or any other Standard Schema compatible library
+```
+
+## Quick Start
+
+### Basic Usage
+
+```typescript
+import { Env } from 'enwow'
+import { z } from 'zod'
+
+// Define your schema
+const env = await Env.create({
+  PORT: z.string().transform(Number).default('3000'),
+  HOST: z.string().default('localhost'),
+  DATABASE_URL: z.string().url(),
+  DEBUG: z.string().optional(),
+})
+
+// Type-safe access
+env.get('PORT') // number
+env.get('HOST') // string
+env.get('DATABASE_URL') // string
+env.get('DEBUG') // string | undefined
+```
+
+### With .env Files
+
+```typescript
+import { Env } from 'enwow'
+import { z } from 'zod'
+
+const env = await Env.create(new URL('./', import.meta.url), {
+  PORT: z.string().transform(Number).default('3000'),
+  HOST: z.string().default('localhost'),
+})
+
+// Values from .env files are loaded and validated
+```
+
+## File Loading Priority
+
+Files are loaded in the following order (highest priority first):
+
+| Priority | File Name | Environment | Notes |
+|----------|-----------|-------------|-------|
+| 1st | `.env.[NODE_ENV].local` | Current environment | Loaded when NODE_ENV is set |
+| 2nd | `.env.local` | All | Not loaded in test environment |
+| 3rd | `.env.[NODE_ENV]` | Current environment | Loaded when NODE_ENV is set |
+| 4th | `.env` | All | Always loaded |
+
+`process.env` always has the highest priority and will override values from any file.
+
+## API
+
+### `Env.create(schema, options?)`
+
+Create a new Env instance without loading .env files.
+
+```typescript
+const env = await Env.create({
+  PORT: z.string().transform(Number),
+})
+```
+
+### `Env.create(path, schema, options?)`
+
+Create a new Env instance and load .env files from the specified directory.
+
+```typescript
+const env = await Env.create(new URL('./', import.meta.url), {
+  PORT: z.string().transform(Number),
+})
+```
+
+### Options
+
+```typescript
+interface EnvCreateOptions {
+  // Ignore existing process.env values
+  ignoreProcessEnv?: boolean
+
+  // Override NODE_ENV for file loading
+  nodeEnv?: string
+
+  // Custom environment variables source
+  envSource?: Record<string, string | undefined>
+}
+```
+
+### `env.get(key)`
+
+Get a validated environment variable value.
+
+```typescript
+const port = env.get('PORT') // Type: number
+```
+
+### `env.all()`
+
+Get all validated environment variables as an object.
+
+```typescript
+const all = env.all() // Type: { PORT: number, HOST: string, ... }
+```
+
+### `env.has(key)`
+
+Check if a variable is defined.
+
+```typescript
+if (env.has('DEBUG')) {
+  // ...
+}
+```
+
+## Error Handling
+
+When validation fails, an `EnvValidationError` is thrown:
+
+```typescript
+import { EnvValidationError } from 'enwow'
+
+try {
+  const env = await Env.create({
+    REQUIRED_VAR: z.string(),
+  })
+}
+catch (error) {
+  if (error instanceof EnvValidationError) {
+    console.log('Validation failed:')
+    for (const issue of error.issues) {
+      console.log(`  ${issue.path}: ${issue.message}`)
+    }
+  }
+}
+```
+
+## Advanced Usage
+
+### With Valibot
+
+```typescript
+import { Env } from 'enwow'
+import * as v from 'valibot'
+
+const env = await Env.create({
+  PORT: v.pipe(v.string(), v.transform(Number), v.minValue(1), v.maxValue(65535)),
+  HOST: v.optional(v.string(), 'localhost'),
+})
+```
+
+### With ArkType
+
+```typescript
+import { type } from 'arktype'
+import { Env } from 'enwow'
+
+const env = await Env.create({
+  PORT: type('string.integer').pipe(Number),
+  HOST: type('string').default('localhost'),
+})
+```
+
+### Manual Validation
+
+```typescript
+import { EnvValidator, parseEnv } from 'enwow'
+import { z } from 'zod'
+
+const validator = new EnvValidator({
+  PORT: z.string().transform(Number),
+})
+
+const result = validator.validate(process.env)
+```
+
+### Direct File Parsing
+
+```typescript
+import { EnvLoader, EnvParser } from 'enwow'
+
+const loader = new EnvLoader(new URL('./', import.meta.url))
+const files = await loader.load()
+
+for (const file of files) {
+  const parser = new EnvParser(file.contents)
+  const parsed = parser.parse()
+  console.log(parsed)
+}
+```
+
+## Contribution
+
+<details>
+  <summary>Local development</summary>
+
+- Clone this repository
+- Install the latest LTS version of [Node.js](https://nodejs.org/en/)
+- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`
+- Install dependencies using `pnpm install`
+- Run tests using `pnpm test`
+
+</details>
+
+## License
+
+[MIT](./LICENSE.md) License
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/enwow?style=flat&colorA=080f12&colorB=1fa669
+[npm-version-href]: https://npmjs.com/package/enwow
+[npm-downloads-src]: https://img.shields.io/npm/dm/enwow?style=flat&colorA=080f12&colorB=1fa669
+[npm-downloads-href]: https://npmjs.com/package/enwow
+[bundle-src]: https://img.shields.io/bundlephobia/minzip/enwow?style=flat&colorA=080f12&colorB=1fa669&label=minzip
+[bundle-href]: https://bundlephobia.com/result?p=enwow
+[license-src]: https://img.shields.io/github/license/enwow/enwow.svg?style=flat&colorA=080f12&colorB=1fa669
+[license-href]: https://github.com/enwow/enwow/blob/main/LICENSE.md

package/dist/index.d.mts

@@ -0,0 +1,322 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/types.d.ts
+
+/**
+ * Extract the output type from a Standard Schema
+ */
+type SchemaOutput<T> = T extends StandardSchemaV1<infer _Input, infer Output> ? Output : never;
+/**
+ * Extract the input type from a Standard Schema
+ */
+type SchemaInput<T> = T extends StandardSchemaV1<infer Input, infer _Output> ? Input : never;
+/**
+ * A schema that conforms to Standard Schema specification
+ */
+type Schema<T = unknown> = StandardSchemaV1<T>;
+/**
+ * Record of schemas for environment variables
+ */
+type EnvSchema = Record<string, Schema>;
+/**
+ * Infer the validated output type from a schema record
+ */
+type InferEnv<T extends EnvSchema> = { [K in keyof T]: SchemaOutput<T[K]> };
+/**
+ * Options for Env.create()
+ */
+interface EnvCreateOptions {
+  /**
+   * Ignore existing process.env values
+   * @default false
+   */
+  ignoreProcessEnv?: boolean;
+  /**
+   * Override the NODE_ENV value for file loading
+   * Useful for testing
+   */
+  nodeEnv?: string;
+  /**
+   * Custom environment variables source
+   * Useful for testing or custom sources
+   */
+  envSource?: Record<string, string | undefined>;
+}
+/**
+ * Environment variable validation issue
+ */
+interface EnvIssue {
+  /**
+   * The path to the variable (usually the variable name)
+   */
+  path?: string;
+  /**
+   * The error message
+   */
+  message: string;
+}
+/**
+ * Result of loading .env files
+ */
+interface LoadedEnvFile {
+  /**
+   * Path to the loaded file
+   */
+  path: string;
+  /**
+   * Raw contents of the file
+   */
+  contents: string;
+}
+/**
+ * Parsed environment variables
+ */
+type ParsedEnv = Record<string, string>;
+//#endregion
+//#region src/env.d.ts
+/**
+ * Env class for managing environment variables
+ *
+ * Provides type-safe access to environment variables after validation
+ *
+ * @example
+ * ```ts
+ * import { Env } from 'enwow'
+ * import { z } from 'zod'
+ *
+ * // Create with path to load .env files
+ * const env = await Env.create(new URL('./', import.meta.url), {
+ *   PORT: z.string().transform(Number).default('3000'),
+ *   HOST: z.string().default('localhost'),
+ * })
+ *
+ * // Or create without path (only process.env)
+ * const env = await Env.create({
+ *   PORT: z.string().transform(Number),
+ * })
+ *
+ * // Type-safe access
+ * env.get('PORT') // number
+ * env.get('HOST') // string
+ * ```
+ */
+declare class Env<T extends EnvSchema> {
+  private readonly values;
+  private constructor();
+  /**
+   * Create a new Env instance
+   *
+   * @param pathOrSchema - Either a URL path to load .env files from, or a schema object
+   * @param schema - The schema definition (required if pathOrSchema is a URL)
+   * @param options - Options for loading and validation
+   * @returns A new Env instance with validated values
+   *
+   * @example
+   * ```ts
+   * // With .env file loading
+   * const env = await Env.create(new URL('./', import.meta.url), {
+   *   PORT: z.string().transform(Number),
+   * })
+   *
+   * // Without .env file loading
+   * const env = await Env.create({
+   *   PORT: z.string().transform(Number),
+   * })
+   * ```
+   */
+  static create<T extends EnvSchema>(schema: T, options?: EnvCreateOptions): Promise<Env<T>>;
+  static create<T extends EnvSchema>(path: URL, schema: T, options?: EnvCreateOptions): Promise<Env<T>>;
+  /**
+   * Get a validated environment variable value
+   * @param key - The variable name
+   * @returns The validated value
+   */
+  get<K$1 extends keyof T>(key: K$1): InferEnv<T>[K$1];
+  /**
+   * Get all validated environment variables as an object
+   */
+  all(): InferEnv<T>;
+  /**
+   * Check if a variable is defined
+   */
+  has(key: keyof T): boolean;
+}
+//#endregion
+//#region src/errors.d.ts
+/**
+ * Error thrown when environment variables validation fails
+ */
+declare class EnvValidationError extends Error {
+  name: string;
+  issues: EnvIssue[];
+  constructor(issues: EnvIssue[]);
+  constructor(message: string, issues?: EnvIssue[]);
+}
+/**
+ * Error thrown when a required environment variable is missing
+ */
+declare class EnvMissingError extends Error {
+  name: string;
+  variableName: string;
+  constructor(variableName: string);
+}
+//#endregion
+//#region src/loader.d.ts
+interface LoaderOptions {
+  /**
+   * The NODE_ENV value to use for determining which files to load
+   * Defaults to process.env.NODE_ENV
+   */
+  nodeEnv?: string;
+  /**
+   * Files to load (override default file resolution)
+   */
+  files?: string[];
+}
+/**
+ * Environment file loader
+ *
+ * Loads .env files from a directory with the following priority (highest first):
+ * 1. .env.[NODE_ENV].local - Loaded when NODE_ENV is set
+ * 2. .env.local - Loaded in all environments except test
+ * 3. .env.[NODE_ENV] - Loaded when NODE_ENV is set
+ * 4. .env - Loaded in all environments
+ *
+ * @example
+ * ```ts
+ * import { EnvLoader } from 'enwow'
+ *
+ * const loader = new EnvLoader(new URL('./', import.meta.url))
+ * const files = await loader.load()
+ *
+ * for (const file of files) {
+ *   console.log(file.path, file.contents)
+ * }
+ * ```
+ */
+declare class EnvLoader {
+  private readonly directory;
+  private readonly options;
+  /**
+   * Create a new EnvLoader
+   * @param directory - The directory to load .env files from (as URL or string path)
+   * @param options - Loader options
+   */
+  constructor(directory: URL | string, options?: LoaderOptions);
+  /**
+   * Load all .env files and return their contents
+   * Files are returned in priority order (highest priority first)
+   */
+  load(): Promise<LoadedEnvFile[]>;
+  /**
+   * Get the list of .env file names to load, in priority order
+   */
+  private getFileNames;
+  private getNodeEnv;
+  /**
+   * Read a file contents in a cross-platform way
+   */
+  private readFile;
+}
+/**
+ * Convenience function to load .env files from a directory
+ */
+declare function loadEnv(directory: URL | string, options?: LoaderOptions): Promise<LoadedEnvFile[]>;
+//#endregion
+//#region src/parser.d.ts
+interface ParseOptions {
+  /**
+   * Ignore existing process.env values when resolving interpolations
+   * @default false
+   */
+  ignoreProcessEnv?: boolean;
+  /**
+   * Custom environment source for interpolation
+   */
+  envSource?: Record<string, string | undefined>;
+}
+/**
+ * Parse .env file contents into a key-value object
+ *
+ * Supports:
+ * - Comments (lines starting with #)
+ * - Empty lines
+ * - Single and double quoted values
+ * - Multi-line values with quoted strings
+ * - Variable interpolation with $VAR or ${VAR} syntax (not in single quotes)
+ *
+ * @example
+ * ```ts
+ * const parser = new EnvParser(`
+ *   PORT=3000
+ *   HOST=localhost
+ *   MESSAGE="Hello World"
+ * `)
+ * const result = parser.parse()
+ * // { PORT: '3000', HOST: 'localhost', MESSAGE: 'Hello World' }
+ * ```
+ */
+declare class EnvParser {
+  private readonly contents;
+  private readonly options;
+  constructor(contents: string, options?: ParseOptions);
+  /**
+   * Parse the .env contents and return a key-value object
+   */
+  parse(): ParsedEnv;
+  /**
+   * Extract value from quoted string, removing the quotes
+   */
+  private extractQuotedValue;
+  /**
+   * Interpolate variables in a value
+   * Supports $VAR and ${VAR} syntax
+   */
+  private interpolate;
+}
+/**
+ * Convenience function to parse .env contents
+ */
+declare function parseEnv(contents: string, options?: ParseOptions): ParsedEnv;
+//#endregion
+//#region src/validator.d.ts
+/**
+ * Validator for environment variables using Standard Schema
+ *
+ * @example
+ * ```ts
+ * import { EnvValidator } from 'enwow'
+ * import { z } from 'zod'
+ *
+ * const validator = new EnvValidator({
+ *   PORT: z.string().transform(Number),
+ *   HOST: z.string().default('localhost'),
+ * })
+ *
+ * const result = validator.validate(process.env)
+ * // result is typed as { PORT: number, HOST: string }
+ * ```
+ */
+declare class EnvValidator<T extends EnvSchema> {
+  private readonly schema;
+  constructor(schema: T);
+  /**
+   * Validate environment variables against the schema
+   * @param env - The environment variables to validate
+   * @returns The validated and transformed environment variables
+   * @throws EnvValidationError if validation fails
+   */
+  validate(env: Record<string, string | undefined>): InferEnv<T>;
+  /**
+   * Validate a single value against its schema
+   */
+  private validateValue;
+}
+/**
+ * Create a validator for environment variables
+ * @param schema - The schema definition
+ * @returns A validator instance
+ */
+declare function createValidator<T extends EnvSchema>(schema: T): EnvValidator<T>;
+//#endregion
+export { Env, type EnvCreateOptions, type EnvIssue, EnvLoader, EnvMissingError, EnvParser, type EnvSchema, EnvValidationError, EnvValidator, type InferEnv, type LoadedEnvFile, type LoaderOptions, type ParseOptions, type ParsedEnv, type Schema, type SchemaInput, type SchemaOutput, createValidator, loadEnv, parseEnv };

package/dist/index.mjs

@@ -0,0 +1,416 @@
+import { env, runtime } from "std-env";
+import { basename, join } from "pathe";
+
+//#region src/loader.ts
+/**
+* Environment file loader
+*
+* Loads .env files from a directory with the following priority (highest first):
+* 1. .env.[NODE_ENV].local - Loaded when NODE_ENV is set
+* 2. .env.local - Loaded in all environments except test
+* 3. .env.[NODE_ENV] - Loaded when NODE_ENV is set
+* 4. .env - Loaded in all environments
+*
+* @example
+* ```ts
+* import { EnvLoader } from 'enwow'
+*
+* const loader = new EnvLoader(new URL('./', import.meta.url))
+* const files = await loader.load()
+*
+* for (const file of files) {
+*   console.log(file.path, file.contents)
+* }
+* ```
+*/
+var EnvLoader = class {
+	directory;
+	options;
+	/**
+	* Create a new EnvLoader
+	* @param directory - The directory to load .env files from (as URL or string path)
+	* @param options - Loader options
+	*/
+	constructor(directory, options = {}) {
+		this.directory = directory instanceof URL ? directory.pathname : directory;
+		this.options = options;
+	}
+	/**
+	* Load all .env files and return their contents
+	* Files are returned in priority order (highest priority first)
+	*/
+	async load() {
+		const files = await this.getFileNames();
+		const results = [];
+		for (const fileName of files) {
+			const filePath = join(this.directory, fileName);
+			try {
+				const contents = await this.readFile(filePath);
+				if (contents !== null) results.push({
+					path: filePath,
+					contents
+				});
+			} catch {}
+		}
+		return results;
+	}
+	/**
+	* Get the list of .env file names to load, in priority order
+	*/
+	async getFileNames() {
+		if (this.options.files) return this.options.files.map((f) => basename(f));
+		const nodeEnv = this.options.nodeEnv ?? await this.getNodeEnv();
+		const files = [];
+		if (nodeEnv) files.push(`.env.${nodeEnv}.local`);
+		if (!(nodeEnv === "test" || nodeEnv === "testing")) files.push(".env.local");
+		if (nodeEnv) files.push(`.env.${nodeEnv}`);
+		files.push(".env");
+		return files;
+	}
+	async getNodeEnv() {
+		return env.NODE_ENV;
+	}
+	/**
+	* Read a file contents in a cross-platform way
+	*/
+	async readFile(path) {
+		if (runtime === "bun") {
+			const file = Bun.file(path);
+			if (!await file.exists()) return null;
+			return file.text();
+		}
+		if (runtime === "deno") try {
+			return await Deno.readTextFile(path);
+		} catch {
+			return null;
+		}
+		const { readFile } = await import("node:fs/promises");
+		try {
+			return await readFile(path, "utf-8");
+		} catch {
+			return null;
+		}
+	}
+};
+/**
+* Convenience function to load .env files from a directory
+*/
+async function loadEnv(directory, options) {
+	return new EnvLoader(directory, options).load();
+}
+
+//#endregion
+//#region src/parser.ts
+/**
+* Parse .env file contents into a key-value object
+*
+* Supports:
+* - Comments (lines starting with #)
+* - Empty lines
+* - Single and double quoted values
+* - Multi-line values with quoted strings
+* - Variable interpolation with $VAR or ${VAR} syntax (not in single quotes)
+*
+* @example
+* ```ts
+* const parser = new EnvParser(`
+*   PORT=3000
+*   HOST=localhost
+*   MESSAGE="Hello World"
+* `)
+* const result = parser.parse()
+* // { PORT: '3000', HOST: 'localhost', MESSAGE: 'Hello World' }
+* ```
+*/
+var EnvParser = class {
+	contents;
+	options;
+	constructor(contents, options = {}) {
+		this.contents = contents;
+		this.options = options;
+	}
+	/**
+	* Parse the .env contents and return a key-value object
+	*/
+	parse() {
+		const result = {};
+		const lines = this.contents.split(/\r?\n/);
+		let currentLine = "";
+		let inQuotes = null;
+		let currentKey = "";
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i];
+			if (inQuotes) {
+				currentLine += `\n${line}`;
+				if (line.includes(inQuotes)) {
+					const cleanValue = this.extractQuotedValue(currentLine, inQuotes);
+					if (inQuotes === "'") result[currentKey] = cleanValue;
+					else result[currentKey] = this.interpolate(cleanValue, result);
+					inQuotes = null;
+					currentLine = "";
+					currentKey = "";
+				}
+				continue;
+			}
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const equalsIndex = trimmed.indexOf("=");
+			if (equalsIndex === -1) continue;
+			const key = trimmed.slice(0, equalsIndex).trim();
+			let value = trimmed.slice(equalsIndex + 1);
+			const firstChar = value[0];
+			if (firstChar === "\"" || firstChar === "'") {
+				const closingQuote = value.lastIndexOf(firstChar);
+				if (closingQuote > 0 && closingQuote !== 0) {
+					const cleanValue = this.extractQuotedValue(value, firstChar);
+					if (firstChar === "'") result[key] = cleanValue;
+					else result[key] = this.interpolate(cleanValue, result);
+				} else {
+					inQuotes = firstChar;
+					currentLine = value;
+					currentKey = key;
+				}
+			} else {
+				const commentIndex = value.indexOf(" #");
+				if (commentIndex !== -1) value = value.slice(0, commentIndex);
+				value = value.trim();
+				result[key] = this.interpolate(value, result);
+			}
+		}
+		return result;
+	}
+	/**
+	* Extract value from quoted string, removing the quotes
+	*/
+	extractQuotedValue(value, quote) {
+		let cleanValue = value.slice(1);
+		const closingIndex = cleanValue.lastIndexOf(quote);
+		if (closingIndex !== -1) cleanValue = cleanValue.slice(0, closingIndex);
+		return cleanValue;
+	}
+	/**
+	* Interpolate variables in a value
+	* Supports $VAR and ${VAR} syntax
+	*/
+	interpolate(value, parsed) {
+		const envSource = this.options.envSource ?? env;
+		let result = value.replace(/\$\{([^}]+)\}/g, (_, varName) => {
+			if (parsed[varName] !== void 0) return parsed[varName];
+			if (!this.options.ignoreProcessEnv && envSource[varName] !== void 0) return envSource[varName];
+			return "";
+		});
+		result = result.replace(/(?<!\$)\$([A-Z_]\w*)/gi, (_, varName) => {
+			if (parsed[varName] !== void 0) return parsed[varName];
+			if (!this.options.ignoreProcessEnv && envSource[varName] !== void 0) return envSource[varName];
+			return "";
+		});
+		return result;
+	}
+};
+/**
+* Convenience function to parse .env contents
+*/
+function parseEnv(contents, options) {
+	return new EnvParser(contents, options).parse();
+}
+
+//#endregion
+//#region src/errors.ts
+/**
+* Error thrown when environment variables validation fails
+*/
+var EnvValidationError = class EnvValidationError extends Error {
+	name = "EnvValidationError";
+	issues;
+	constructor(messageOrIssues, issues) {
+		if (typeof messageOrIssues === "string") {
+			super(messageOrIssues);
+			this.issues = issues ?? [];
+		} else {
+			super("Environment variables validation failed");
+			this.issues = messageOrIssues;
+		}
+		Error.captureStackTrace?.(this, EnvValidationError);
+	}
+};
+/**
+* Error thrown when a required environment variable is missing
+*/
+var EnvMissingError = class EnvMissingError extends Error {
+	name = "EnvMissingError";
+	variableName;
+	constructor(variableName) {
+		super(`Missing required environment variable: ${variableName}`);
+		this.variableName = variableName;
+		Error.captureStackTrace?.(this, EnvMissingError);
+	}
+};
+
+//#endregion
+//#region src/validator.ts
+/**
+* Validator for environment variables using Standard Schema
+*
+* @example
+* ```ts
+* import { EnvValidator } from 'enwow'
+* import { z } from 'zod'
+*
+* const validator = new EnvValidator({
+*   PORT: z.string().transform(Number),
+*   HOST: z.string().default('localhost'),
+* })
+*
+* const result = validator.validate(process.env)
+* // result is typed as { PORT: number, HOST: string }
+* ```
+*/
+var EnvValidator = class {
+	schema;
+	constructor(schema) {
+		this.schema = schema;
+	}
+	/**
+	* Validate environment variables against the schema
+	* @param env - The environment variables to validate
+	* @returns The validated and transformed environment variables
+	* @throws EnvValidationError if validation fails
+	*/
+	validate(env$1) {
+		const result = {};
+		const issues = [];
+		for (const [key, schema] of Object.entries(this.schema)) {
+			const value = env$1[key];
+			const validationResult = this.validateValue(schema, value, key);
+			if (validationResult.success) result[key] = validationResult.value;
+			else issues.push(...validationResult.issues);
+		}
+		if (issues.length > 0) throw new EnvValidationError(issues);
+		return result;
+	}
+	/**
+	* Validate a single value against its schema
+	*/
+	validateValue(schema, value, key) {
+		const result = schema["~standard"].validate(value);
+		if (result instanceof Promise) throw new TypeError(`Async validation is not supported. The schema for "${key}" appears to be async. Please use synchronous schemas only.`);
+		if (result.issues === void 0) return {
+			success: true,
+			value: result.value
+		};
+		return {
+			success: false,
+			issues: result.issues.map((issue) => ({
+				path: key,
+				message: issue.message
+			}))
+		};
+	}
+};
+/**
+* Create a validator for environment variables
+* @param schema - The schema definition
+* @returns A validator instance
+*/
+function createValidator(schema) {
+	return new EnvValidator(schema);
+}
+
+//#endregion
+//#region src/env.ts
+/**
+* Env class for managing environment variables
+*
+* Provides type-safe access to environment variables after validation
+*
+* @example
+* ```ts
+* import { Env } from 'enwow'
+* import { z } from 'zod'
+*
+* // Create with path to load .env files
+* const env = await Env.create(new URL('./', import.meta.url), {
+*   PORT: z.string().transform(Number).default('3000'),
+*   HOST: z.string().default('localhost'),
+* })
+*
+* // Or create without path (only process.env)
+* const env = await Env.create({
+*   PORT: z.string().transform(Number),
+* })
+*
+* // Type-safe access
+* env.get('PORT') // number
+* env.get('HOST') // string
+* ```
+*/
+var Env = class Env {
+	values;
+	constructor(values) {
+		this.values = values;
+	}
+	static async create(pathOrSchema, schemaOrOptions, options) {
+		let path;
+		let schema;
+		let opts = {};
+		if (pathOrSchema instanceof URL) {
+			path = pathOrSchema;
+			schema = schemaOrOptions;
+			opts = options ?? {};
+		} else {
+			schema = pathOrSchema;
+			opts = schemaOrOptions ?? {};
+		}
+		let envValues = {};
+		if (path) {
+			const files = await new EnvLoader(path, { nodeEnv: opts.nodeEnv }).load();
+			for (const file of files.reverse()) {
+				const parsed = new EnvParser(file.contents, {
+					ignoreProcessEnv: opts.ignoreProcessEnv,
+					envSource: opts.envSource
+				}).parse();
+				envValues = {
+					...envValues,
+					...parsed
+				};
+			}
+		}
+		if (!opts.ignoreProcessEnv) {
+			const processEnv = opts.envSource ?? getProcessEnv();
+			envValues = {
+				...envValues,
+				...processEnv
+			};
+		}
+		return new Env(new EnvValidator(schema).validate(envValues));
+	}
+	/**
+	* Get a validated environment variable value
+	* @param key - The variable name
+	* @returns The validated value
+	*/
+	get(key) {
+		return this.values[key];
+	}
+	/**
+	* Get all validated environment variables as an object
+	*/
+	all() {
+		return { ...this.values };
+	}
+	/**
+	* Check if a variable is defined
+	*/
+	has(key) {
+		return this.values[key] !== void 0;
+	}
+};
+/**
+* Get the current process environment in a cross-platform way
+*/
+function getProcessEnv() {
+	return env;
+}
+
+//#endregion
+export { Env, EnvLoader, EnvMissingError, EnvParser, EnvValidationError, EnvValidator, createValidator, loadEnv, parseEnv };

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "enwow",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "Cross-platform environment variables loader and validator with Standard Schema support",
+  "author": "blasdfaa",
+  "license": "MIT",
+  "homepage": "https://github.com/blasdfaa/enwow#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/blasdfaa/enwow.git"
+  },
+  "bugs": "https://github.com/blasdfaa/enwow/issues",
+  "keywords": [
+    "env",
+    "environment",
+    "variables",
+    "dotenv",
+    "validation",
+    "standard-schema",
+    "zod",
+    "valibot",
+    "arktype",
+    "typescript"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "pathe": "^2.0.0",
+    "std-env": "^4.0.0-rc.1"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^6.6.1",
+    "@antfu/ni": "^28.0.0",
+    "@antfu/utils": "^9.3.0",
+    "@standard-schema/spec": "^1.0.0",
+    "@types/node": "^25.0.1",
+    "bumpp": "^10.3.2",
+    "eslint": "^9.39.2",
+    "lint-staged": "^16.2.7",
+    "publint": "^0.3.16",
+    "simple-git-hooks": "^2.13.1",
+    "tinyexec": "^1.0.2",
+    "tsdown": "^0.17.3",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vite": "^7.2.7",
+    "vitest": "^4.0.15",
+    "vitest-package-exports": "^0.1.1",
+    "yaml": "^2.8.2",
+    "zod": "^3.24.0"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpm i --frozen-lockfile --ignore-scripts --offline && npx lint-staged"
+  },
+  "lint-staged": {
+    "*": "eslint --fix"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "lint": "eslint",
+    "release": "bumpp",
+    "test": "vitest",
+    "typecheck": "tsc"
+  }
+}