@systemix/env 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 shahadathhs
+
+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,127 @@
+# @systemix/env
+
+Typed environment variable loading and validation. Zero dependencies. Built-in .env file support.
+
+## Installation
+
+```bash
+pnpm add @systemix/env
+```
+
+## Usage
+
+```typescript
+import { load } from '@systemix/env';
+
+const env = load({
+  NODE_ENV: { type: 'string', default: 'development' },
+  PORT: { type: 'number', default: 3000 },
+  DATABASE_URL: { type: 'string', required: true, secret: true },
+  DEBUG: { type: 'boolean', default: false },
+});
+
+console.log(env.PORT); // number
+console.log(env.toSafeLog()); // { DATABASE_URL: '***', ... }
+```
+
+## Schema
+
+| Property    | Type                                | Description                       |
+| ----------- | ----------------------------------- | --------------------------------- |
+| `type`      | `'string' \| 'number' \| 'boolean'` | How to parse the value            |
+| `required`  | `boolean`                           | If true, throws when missing      |
+| `default`   | `string \| number \| boolean`       | Used when var is missing or empty |
+| `min`       | `number`                            | Min value (number type)           |
+| `max`       | `number`                            | Max value (number type)           |
+| `regex`     | `RegExp`                            | Must match (string type)          |
+| `oneOf`     | `string[]`                          | Allowed values (string type)      |
+| `transform` | `(raw) => value`                    | Custom parser                     |
+| `secret`    | `boolean`                           | Masked in `toSafeLog()`           |
+
+## Options
+
+Pass options as second argument. For backward compat, a plain `Record` is treated as `{ source }`:
+
+```typescript
+load(schema, { PORT: '4000' }); // legacy: treated as source
+load(schema, {
+  source: { PORT: '4000' }, // Custom env source
+  fromFile: '.env.local', // Load from .env file(s)
+  fromFile: ['.env', '.env.local'], // Multiple files, later overrides
+  strict: true, // Ignore vars not in schema
+});
+```
+
+## .env File Loading
+
+Load from file. Cross-platform (Windows, macOS, Linux).
+
+```typescript
+const env = load(schema, { fromFile: '.env.local' });
+```
+
+Or parse content yourself:
+
+```typescript
+import { parseEnvFile } from '@systemix/env';
+
+const vars = parseEnvFile(readFileSync('.env', 'utf-8'));
+```
+
+## Secret Masking
+
+Mark sensitive vars with `secret: true`. Use `toSafeLog()` for logging:
+
+```typescript
+const env = load(
+  {
+    API_KEY: { type: 'string', secret: true },
+    PORT: { type: 'number' },
+  },
+  { source: { API_KEY: 'sk-123', PORT: '3000' } },
+);
+
+console.log(env.toSafeLog());
+// { API_KEY: '***', PORT: 3000 }
+```
+
+## Batch Error Reporting
+
+All validation errors are collected and thrown together:
+
+```
+Env validation failed:
+  - Missing required env var: DATABASE_URL
+  - PORT: must be >= 1
+```
+
+## Config (OOP)
+
+Class-based usage with get, getOrThrow, has:
+
+```typescript
+import { Config } from '@systemix/env';
+
+const config = Config.fromEnv({
+  PORT: { type: 'number', default: 3000 },
+  DATABASE_URL: { type: 'string', required: true },
+});
+
+config.get('PORT'); // number | undefined
+config.get('PORT', 4000); // number (default when undefined)
+config.getOrThrow('DATABASE_URL'); // throws if not set
+config.has('PORT'); // boolean
+config.toSafeLog(); // masked for logging
+config.getRaw(); // raw env object
+```
+
+Create from existing env: `Config.from(load(schema))`.
+
+## Boolean Parsing
+
+- `true`: `"true"`, `"1"`, `"yes"`
+- `false`: `"false"`, `"0"`, `"no"`, `""`
+
+## License
+
+MIT © [Shahadath Hossen Sajib](https://github.com/shahadathhs)

package/dist/index.cjs

@@ -0,0 +1,243 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Config: () => Config,
+  load: () => load,
+  parseEnvFile: () => parseEnvFile
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/env/parse.ts
+function parseBoolean(raw) {
+  const lower = raw.toLowerCase().trim();
+  if (lower === "true" || lower === "1" || lower === "yes") return true;
+  if (lower === "false" || lower === "0" || lower === "no" || lower === "")
+    return false;
+  throw new Error(`Invalid boolean value: "${raw}"`);
+}
+function parseNumber(raw) {
+  const n = Number(raw);
+  if (!Number.isFinite(n)) {
+    throw new Error(`Invalid number value: "${raw}"`);
+  }
+  return n;
+}
+function parseEnvFile(content) {
+  const result = {};
+  const lines = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1).replace(/\\(.)/g, "$1");
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+// src/env/file.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function loadEnvFile(filePath, cwd) {
+  const resolved = (0, import_node_path.resolve)(cwd, filePath);
+  if (!(0, import_node_fs.existsSync)(resolved)) {
+    return {};
+  }
+  const content = (0, import_node_fs.readFileSync)(resolved, "utf-8");
+  return parseEnvFile(content);
+}
+function getCwd() {
+  return typeof globalThis.process?.cwd === "function" ? globalThis.process.cwd() : ".";
+}
+function mergeEnv(base, overlay) {
+  const merged = { ...base };
+  for (const [k, v] of Object.entries(overlay)) {
+    merged[k] = v;
+  }
+  return merged;
+}
+function getEnvSource() {
+  const env = globalThis.process?.env;
+  if (env && typeof env === "object") {
+    return env;
+  }
+  return {};
+}
+
+// src/env/load.ts
+var MASK = "***";
+function load(schema, options) {
+  const opts = options ?? {};
+  const isLegacySource = opts && typeof opts === "object" && !Array.isArray(opts) && !("source" in opts) && !("fromFile" in opts) && !("strict" in opts);
+  const normalized = isLegacySource ? { source: opts } : opts;
+  const { source, fromFile, strict = false } = normalized;
+  let env = source ?? getEnvSource();
+  if (fromFile) {
+    const cwd = getCwd();
+    const files = Array.isArray(fromFile) ? fromFile : [fromFile];
+    for (const f of files) {
+      const loaded = loadEnvFile(f, cwd);
+      env = mergeEnv(env, loaded);
+    }
+  }
+  if (strict) {
+    const schemaKeys2 = new Set(Object.keys(schema));
+    const filtered = {};
+    for (const [k, v] of Object.entries(env)) {
+      if (schemaKeys2.has(k)) filtered[k] = v;
+    }
+    env = filtered;
+  }
+  const schemaKeys = Object.keys(schema);
+  const errors = [];
+  const result = {};
+  for (const key of schemaKeys) {
+    const def = schema[key];
+    const raw = env[key];
+    const { type, required = false, default: defaultValue } = def;
+    if (raw === void 0 || raw === "") {
+      if (required && defaultValue === void 0) {
+        errors.push(`Missing required env var: ${key}`);
+        continue;
+      }
+      result[key] = defaultValue ?? void 0;
+      continue;
+    }
+    try {
+      let value;
+      if (def.transform) {
+        value = def.transform(raw);
+      } else {
+        switch (type) {
+          case "string":
+            value = raw;
+            break;
+          case "number":
+            value = parseNumber(raw);
+            break;
+          case "boolean":
+            value = parseBoolean(raw);
+            break;
+          default:
+            value = raw;
+        }
+      }
+      if (type === "number" && typeof value === "number") {
+        if (def.min !== void 0 && value < def.min) {
+          errors.push(`${key}: must be >= ${def.min}`);
+          continue;
+        }
+        if (def.max !== void 0 && value > def.max) {
+          errors.push(`${key}: must be <= ${def.max}`);
+          continue;
+        }
+      }
+      if (type === "string" && typeof value === "string") {
+        if (def.regex && !def.regex.test(value)) {
+          errors.push(`${key}: must match ${def.regex}`);
+          continue;
+        }
+        if (def.oneOf && !def.oneOf.includes(value)) {
+          errors.push(`${key}: must be one of [${def.oneOf.join(", ")}]`);
+          continue;
+        }
+      }
+      result[key] = value;
+    } catch (err) {
+      errors.push(
+        `${key}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(
+      `Env validation failed:
+${errors.map((e) => `  - ${e}`).join("\n")}`
+    );
+  }
+  const toSafeLog = () => {
+    const safe = {};
+    for (const key of schemaKeys) {
+      const def = schema[key];
+      const val = result[key];
+      safe[key] = def.secret && val !== void 0 ? MASK : val;
+    }
+    return safe;
+  };
+  return Object.assign(result, { toSafeLog });
+}
+
+// src/config.ts
+var Config = class _Config {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create Config from a schema and env source.
+   * @param schema - Env variable definitions
+   * @param options - Source, fromFile, or strict. Legacy: plain object as source.
+   */
+  static fromEnv(schema, options) {
+    const config = load(schema, options);
+    return new _Config(config);
+  }
+  /** Create Config from an existing load() result. */
+  static from(config) {
+    return new _Config(config);
+  }
+  get(key, defaultValue) {
+    const val = this.config[key];
+    if (defaultValue !== void 0 && val === void 0) return defaultValue;
+    return val;
+  }
+  /** Get value by key, or throw if not set. */
+  getOrThrow(key) {
+    const val = this.config[key];
+    if (val === void 0) {
+      throw new Error(`Config key "${String(key)}" is not set`);
+    }
+    return val;
+  }
+  /** Check if key is set. */
+  has(key) {
+    return this.config[key] !== void 0;
+  }
+  /** Return a copy with secret values masked as '***'. */
+  toSafeLog() {
+    return this.config.toSafeLog();
+  }
+  /** Get the raw env result (no masking). */
+  getRaw() {
+    return this.config;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  load,
+  parseEnvFile
+});

package/dist/index.d.cts

@@ -0,0 +1,43 @@
+type EnvVarType = 'string' | 'number' | 'boolean';
+interface EnvVarSchema<T extends EnvVarType = EnvVarType> {
+    type: T;
+    required?: boolean;
+    default?: T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : never;
+    min?: number;
+    max?: number;
+    regex?: RegExp;
+    oneOf?: readonly string[];
+    transform?: (raw: string) => string | number | boolean;
+    secret?: boolean;
+}
+type EnvSchema = Record<string, EnvVarSchema<'string' | 'number' | 'boolean'>>;
+type EnvValueFor<S extends EnvVarSchema<EnvVarType>> = S['type'] extends 'string' ? string : S['type'] extends 'number' ? number : S['type'] extends 'boolean' ? boolean : never;
+type EnvResult<T extends EnvSchema> = {
+    [K in keyof T]: T[K]['required'] extends true ? EnvValueFor<T[K]> : T[K]['default'] extends EnvValueFor<T[K]> ? EnvValueFor<T[K]> : EnvValueFor<T[K]> | undefined;
+} & {
+    toSafeLog(): Record<string, string | number | boolean | undefined>;
+};
+interface LoadOptions {
+    source?: Record<string, string | undefined>;
+    fromFile?: string | string[];
+    strict?: boolean;
+}
+
+declare function parseEnvFile(content: string): Record<string, string>;
+
+declare function load<T extends EnvSchema>(schema: T, options?: LoadOptions | Record<string, string | undefined>): EnvResult<T>;
+
+declare class Config<T extends EnvSchema> {
+    private readonly config;
+    private constructor();
+    static fromEnv<S extends EnvSchema>(schema: S, options?: LoadOptions | Record<string, string | undefined>): Config<S>;
+    static from<S extends EnvSchema>(config: EnvResult<S>): Config<S>;
+    get<K extends keyof T>(key: K): EnvResult<T>[K] | undefined;
+    get<K extends keyof T>(key: K, defaultValue: EnvResult<T>[K]): EnvResult<T>[K];
+    getOrThrow<K extends keyof T>(key: K): EnvResult<T>[K];
+    has(key: keyof T): boolean;
+    toSafeLog(): Record<string, string | number | boolean | undefined>;
+    getRaw(): EnvResult<T>;
+}
+
+export { Config, type EnvResult, type EnvSchema, type EnvVarSchema, type EnvVarType, type LoadOptions, load, parseEnvFile };

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+type EnvVarType = 'string' | 'number' | 'boolean';
+interface EnvVarSchema<T extends EnvVarType = EnvVarType> {
+    type: T;
+    required?: boolean;
+    default?: T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : never;
+    min?: number;
+    max?: number;
+    regex?: RegExp;
+    oneOf?: readonly string[];
+    transform?: (raw: string) => string | number | boolean;
+    secret?: boolean;
+}
+type EnvSchema = Record<string, EnvVarSchema<'string' | 'number' | 'boolean'>>;
+type EnvValueFor<S extends EnvVarSchema<EnvVarType>> = S['type'] extends 'string' ? string : S['type'] extends 'number' ? number : S['type'] extends 'boolean' ? boolean : never;
+type EnvResult<T extends EnvSchema> = {
+    [K in keyof T]: T[K]['required'] extends true ? EnvValueFor<T[K]> : T[K]['default'] extends EnvValueFor<T[K]> ? EnvValueFor<T[K]> : EnvValueFor<T[K]> | undefined;
+} & {
+    toSafeLog(): Record<string, string | number | boolean | undefined>;
+};
+interface LoadOptions {
+    source?: Record<string, string | undefined>;
+    fromFile?: string | string[];
+    strict?: boolean;
+}
+
+declare function parseEnvFile(content: string): Record<string, string>;
+
+declare function load<T extends EnvSchema>(schema: T, options?: LoadOptions | Record<string, string | undefined>): EnvResult<T>;
+
+declare class Config<T extends EnvSchema> {
+    private readonly config;
+    private constructor();
+    static fromEnv<S extends EnvSchema>(schema: S, options?: LoadOptions | Record<string, string | undefined>): Config<S>;
+    static from<S extends EnvSchema>(config: EnvResult<S>): Config<S>;
+    get<K extends keyof T>(key: K): EnvResult<T>[K] | undefined;
+    get<K extends keyof T>(key: K, defaultValue: EnvResult<T>[K]): EnvResult<T>[K];
+    getOrThrow<K extends keyof T>(key: K): EnvResult<T>[K];
+    has(key: keyof T): boolean;
+    toSafeLog(): Record<string, string | number | boolean | undefined>;
+    getRaw(): EnvResult<T>;
+}
+
+export { Config, type EnvResult, type EnvSchema, type EnvVarSchema, type EnvVarType, type LoadOptions, load, parseEnvFile };

package/dist/index.js

@@ -0,0 +1,214 @@
+// src/env/parse.ts
+function parseBoolean(raw) {
+  const lower = raw.toLowerCase().trim();
+  if (lower === "true" || lower === "1" || lower === "yes") return true;
+  if (lower === "false" || lower === "0" || lower === "no" || lower === "")
+    return false;
+  throw new Error(`Invalid boolean value: "${raw}"`);
+}
+function parseNumber(raw) {
+  const n = Number(raw);
+  if (!Number.isFinite(n)) {
+    throw new Error(`Invalid number value: "${raw}"`);
+  }
+  return n;
+}
+function parseEnvFile(content) {
+  const result = {};
+  const lines = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1).replace(/\\(.)/g, "$1");
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+// src/env/file.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+function loadEnvFile(filePath, cwd) {
+  const resolved = resolve(cwd, filePath);
+  if (!existsSync(resolved)) {
+    return {};
+  }
+  const content = readFileSync(resolved, "utf-8");
+  return parseEnvFile(content);
+}
+function getCwd() {
+  return typeof globalThis.process?.cwd === "function" ? globalThis.process.cwd() : ".";
+}
+function mergeEnv(base, overlay) {
+  const merged = { ...base };
+  for (const [k, v] of Object.entries(overlay)) {
+    merged[k] = v;
+  }
+  return merged;
+}
+function getEnvSource() {
+  const env = globalThis.process?.env;
+  if (env && typeof env === "object") {
+    return env;
+  }
+  return {};
+}
+
+// src/env/load.ts
+var MASK = "***";
+function load(schema, options) {
+  const opts = options ?? {};
+  const isLegacySource = opts && typeof opts === "object" && !Array.isArray(opts) && !("source" in opts) && !("fromFile" in opts) && !("strict" in opts);
+  const normalized = isLegacySource ? { source: opts } : opts;
+  const { source, fromFile, strict = false } = normalized;
+  let env = source ?? getEnvSource();
+  if (fromFile) {
+    const cwd = getCwd();
+    const files = Array.isArray(fromFile) ? fromFile : [fromFile];
+    for (const f of files) {
+      const loaded = loadEnvFile(f, cwd);
+      env = mergeEnv(env, loaded);
+    }
+  }
+  if (strict) {
+    const schemaKeys2 = new Set(Object.keys(schema));
+    const filtered = {};
+    for (const [k, v] of Object.entries(env)) {
+      if (schemaKeys2.has(k)) filtered[k] = v;
+    }
+    env = filtered;
+  }
+  const schemaKeys = Object.keys(schema);
+  const errors = [];
+  const result = {};
+  for (const key of schemaKeys) {
+    const def = schema[key];
+    const raw = env[key];
+    const { type, required = false, default: defaultValue } = def;
+    if (raw === void 0 || raw === "") {
+      if (required && defaultValue === void 0) {
+        errors.push(`Missing required env var: ${key}`);
+        continue;
+      }
+      result[key] = defaultValue ?? void 0;
+      continue;
+    }
+    try {
+      let value;
+      if (def.transform) {
+        value = def.transform(raw);
+      } else {
+        switch (type) {
+          case "string":
+            value = raw;
+            break;
+          case "number":
+            value = parseNumber(raw);
+            break;
+          case "boolean":
+            value = parseBoolean(raw);
+            break;
+          default:
+            value = raw;
+        }
+      }
+      if (type === "number" && typeof value === "number") {
+        if (def.min !== void 0 && value < def.min) {
+          errors.push(`${key}: must be >= ${def.min}`);
+          continue;
+        }
+        if (def.max !== void 0 && value > def.max) {
+          errors.push(`${key}: must be <= ${def.max}`);
+          continue;
+        }
+      }
+      if (type === "string" && typeof value === "string") {
+        if (def.regex && !def.regex.test(value)) {
+          errors.push(`${key}: must match ${def.regex}`);
+          continue;
+        }
+        if (def.oneOf && !def.oneOf.includes(value)) {
+          errors.push(`${key}: must be one of [${def.oneOf.join(", ")}]`);
+          continue;
+        }
+      }
+      result[key] = value;
+    } catch (err) {
+      errors.push(
+        `${key}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(
+      `Env validation failed:
+${errors.map((e) => `  - ${e}`).join("\n")}`
+    );
+  }
+  const toSafeLog = () => {
+    const safe = {};
+    for (const key of schemaKeys) {
+      const def = schema[key];
+      const val = result[key];
+      safe[key] = def.secret && val !== void 0 ? MASK : val;
+    }
+    return safe;
+  };
+  return Object.assign(result, { toSafeLog });
+}
+
+// src/config.ts
+var Config = class _Config {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create Config from a schema and env source.
+   * @param schema - Env variable definitions
+   * @param options - Source, fromFile, or strict. Legacy: plain object as source.
+   */
+  static fromEnv(schema, options) {
+    const config = load(schema, options);
+    return new _Config(config);
+  }
+  /** Create Config from an existing load() result. */
+  static from(config) {
+    return new _Config(config);
+  }
+  get(key, defaultValue) {
+    const val = this.config[key];
+    if (defaultValue !== void 0 && val === void 0) return defaultValue;
+    return val;
+  }
+  /** Get value by key, or throw if not set. */
+  getOrThrow(key) {
+    const val = this.config[key];
+    if (val === void 0) {
+      throw new Error(`Config key "${String(key)}" is not set`);
+    }
+    return val;
+  }
+  /** Check if key is set. */
+  has(key) {
+    return this.config[key] !== void 0;
+  }
+  /** Return a copy with secret values masked as '***'. */
+  toSafeLog() {
+    return this.config.toSafeLog();
+  }
+  /** Get the raw env result (no masking). */
+  getRaw() {
+    return this.config;
+  }
+};
+export {
+  Config,
+  load,
+  parseEnvFile
+};

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@systemix/env",
+  "version": "0.2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shahadathhs/systemix.git",
+    "directory": "packages/env"
+  },
+  "homepage": "https://github.com/shahadathhs/systemix/tree/main/packages/env#readme",
+  "keywords": [
+    "systemix",
+    "env",
+    "environment",
+    "environment-variables",
+    "validation",
+    "typed-env",
+    "typescript",
+    "node",
+    "utility"
+  ],
+  "author": "Shahadath Hossen Sajib <shahadathhossensajib732@gmail.com> (https://github.com/shahadathhs)",
+  "license": "MIT",
+  "description": "Typed environment variable loading and validation. Part of the Systemix toolkit.",
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "eslint": "^10.0.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "@systemix/eslint": "0.4.0",
+    "@systemix/runner": "0.2.0",
+    "@systemix/typescript": "0.4.0"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "sideEffects": false,
+  "bugs": {
+    "url": "https://github.com/shahadathhs/systemix/issues"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test": "pnpm build && node tests/run.mjs",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --check . --ignore-path .prettierignore",
+    "format:fix": "prettier --write . --ignore-path .prettierignore",
+    "clean": "rimraf dist node_modules",
+    "clean:turbo": "rimraf .turbo dist node_modules"
+  }
+}