strict-env-resolver 0.6.6 → 0.7.0

package/README.md

@@ -1,15 +1,17 @@
 # Strict Env Resolver
 
-[![npm version](https://img.shields.io/npm/v/strict-env-resolver.svg)](https://www.npmjs.com/package/strict-env-resolver)
-[![npm downloads](https://img.shields.io/npm/dm/strict-env-resolver.svg)](https://www.npmjs.com/package/strict-env-resolver)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![npm version](https://img.shields.io/npm/v/strict-env-resolver?style=flat-square)](https://www.npmjs.com/package/strict-env-resolver)
+[![license](https://img.shields.io/npm/l/strict-env-resolver?style=flat-square)](https://www.npmjs.com/package/strict-env-resolver)
+[![Node.js](https://img.shields.io/node/v/strict-env-resolver?style=flat-square)](https://www.npmjs.com/package/strict-env-resolver)
+[![build](https://img.shields.io/github/actions/workflow/status/gammarers-labs/strict-env-resolver/build.yml?branch=main&label=build&style=flat-square)](https://github.com/gammarers-labs/strict-env-resolver/actions/workflows/build.yml)
 
 Type-safe environment variable resolver for Node.js. Reads and parses `process.env` with specs (`string`, `number`, `boolean`, `enum`), optional defaults, configurable trimming, and structured validation errors when values are missing or invalid.
 
 ## Features
 
 - **Typed specs**: `string`, `number`, `boolean`, and `enum` with TypeScript inference
-- **Finite numbers**: `StrictEnvType.Number` parses any finite numeric value (`Number()`); rejects `NaN` and `Infinity`
+- **Finite numbers**: `StrictEnvType.Number` accepts finite values and rejects `NaN` and `Infinity`
+- **Number presets**: Nested specs such as `Number.Port`, `Number.Integer`, and `Number.PositiveInteger`
 - **Optional defaults**: Fallback when a variable is unset, empty (`""`), or whitespace-only (when trimming is enabled)
 - **Configurable trim**: `trim` defaults to `true` for parsed types and `false` for strings; override per variable
 - **Batch parsing**: `resolveAll()` evaluates every key and throws once with all validation errors
@@ -17,22 +19,48 @@ Type-safe environment variable resolver for Node.js. Reads and parses `process.e
 - **Boolean parsing**: `1`, `true`, `yes`, `on` (case-insensitive, after trim) → `true`; any other non-empty value → `false`
 - **Enum constraint**: Values must match one of the allowed choices (compared after trim)
 
+## How it works
+
+`resolve` reads one `process.env` key, trims it when the spec says so, parses it, and returns a typed value or throws `StrictEnvValidationError`. `resolveAll` does the same for every key in a schema and throws once with every issue collected.
+
+Unset, empty, and (when trimming) whitespace-only values use `options.default` when provided; otherwise they fail with `kind: 'missing'`.
+
 ## Installation
 
-**npm**
+### npm
 
 ```bash
 npm install strict-env-resolver
 ```
 
-**yarn**
+### yarn
 
 ```bash
 yarn add strict-env-resolver
 ```
 
+### pnpm
+
+```bash
+pnpm add strict-env-resolver
+```
+
 ## Usage
 
+```ts
+import { StrictEnvResolver, StrictEnvType } from 'strict-env-resolver';
+
+const port = StrictEnvResolver.resolve('PORT', StrictEnvType.Number.Port, { default: 3000 });
+
+const envs = StrictEnvResolver.resolveAll({
+  PORT: [StrictEnvType.Number.Port, { default: 3000 }],
+  DEBUG: [StrictEnvType.Boolean, { default: false }],
+  MODE: StrictEnvType.Enum(['read', 'write'] as const),
+});
+```
+
+Strings, custom number bounds, enums, and error handling:
+
 ```ts
 import {
   StrictEnvResolver,
@@ -53,15 +81,18 @@ const trimmedLogLevel = StrictEnvResolver.resolve('LOG_LEVEL', StrictEnvType.Str
   default: 'info',
 });
 
-// Number (e.g. port, ratio, timeout)
-const port = StrictEnvResolver.resolve('PORT', StrictEnvType.Number, { default: 3000 });
+// Number (e.g. ratio, timeout)
+const timeoutMs = StrictEnvResolver.resolve('TIMEOUT_MS', StrictEnvType.Number, { default: 5000 });
 // Valid: "42", "-1", "3.14", "1e5", "+42", "0x10", "  42  " (trimmed)
 // Missing: "", "   " (whitespace-only, trim default true)
 // Invalid: "Infinity", "NaN", "not-a-number"
 
+// Number presets
+const retries = StrictEnvResolver.resolve('RETRIES', StrictEnvType.Number.NonNegativeInteger, { default: 0 });
+// Custom bounds: StrictEnvType.Number({ min: 1, max: 1024, integer: true })
+
 // Boolean (1/true/yes/on → true after trim; other non-empty values → false)
 const debug = StrictEnvResolver.resolve('DEBUG', StrictEnvType.Boolean, { default: false });
-// " true " → true
 
 // Enum (value must be in choices, compared after trim)
 const mode = StrictEnvResolver.resolve('MODE', StrictEnvType.Enum(['read', 'write'] as const));
@@ -71,18 +102,9 @@ const modeWithDefault = StrictEnvResolver.resolve(
   { default: 'read' },
 );
 
-// Read multiple env vars at once (collects all errors, then throws once)
-const envs = StrictEnvResolver.resolveAll({
-  PORT: [StrictEnvType.Number, { default: 3000 }],
-  DEBUG: [StrictEnvType.Boolean, { default: false }],
-  MODE: StrictEnvType.Enum(['read', 'write'] as const),
-  LOG_LEVEL: [StrictEnvType.String, { trim: true, default: 'info' }],
-});
-
-// Handle structured validation errors
 try {
   StrictEnvResolver.resolveAll({
-    PORT: StrictEnvType.Number,
+    PORT: StrictEnvType.Number.Port,
     MODE: StrictEnvType.Enum(['read', 'write'] as const),
   });
 } catch (e) {
@@ -105,15 +127,15 @@ try {
 | Argument | Required | Description |
 |----------|----------|-------------|
 | **key** | Yes | Environment variable name (e.g. `"PORT"`, `"NODE_ENV"`). |
-| **spec** | No | Type spec; defaults to `StrictEnvType.String`. Use `StrictEnvType.String`, `StrictEnvType.Number`, `StrictEnvType.Boolean`, or `StrictEnvType.Enum(choices)`. |
+| **spec** | No | Type spec; defaults to `StrictEnvType.String`. Use `StrictEnvType.String`, `StrictEnvType.Number` (or a nested preset such as `Number.Port`), `StrictEnvType.Boolean`, or `StrictEnvType.Enum(choices)`. |
 | **options** | No | See [`StrictEnvOptions`](#strictenvoptions) below. |
 
 ### `StrictEnvResolver.resolveAll(schema)`
 
 `schema` is an object where each key is an env var name and each value is either:
 
-- A spec (e.g. `StrictEnvType.Number`)
-- A tuple `[spec, options]` (e.g. `[StrictEnvType.Number, { default: 3000, trim: true }]`)
+- A spec (e.g. `StrictEnvType.Number.Port`)
+- A tuple `[spec, options]` (e.g. `[StrictEnvType.Number.Port, { default: 3000, trim: true }]`)
 
 Evaluates every entry in `schema`. If any value is missing, empty without a default, whitespace-only without a default (when trimming is enabled), or invalid, throws a single `StrictEnvValidationError` containing all issues.
 
@@ -129,7 +151,7 @@ Evaluates every entry in `schema`. If any value is missing, empty without a defa
 | Spec | Constant | Description |
 |------|----------|-------------|
 | `string` | `StrictEnvType.String` | Raw string value. Not trimmed by default; set `trim: true` to trim and treat whitespace-only as missing. |
-| `number` | `StrictEnvType.Number` | Finite numeric value (see below). Trimmed by default. |
+| `number` | `StrictEnvType.Number` | Finite numeric value (see below). Trimmed by default. Nested presets such as `Number.Port` are still `number` specs. |
 | `boolean` | `StrictEnvType.Boolean` | `1` / `true` / `yes` / `on` (case-insensitive, trimmed) → `true`; otherwise → `false`. Trimmed by default. |
 | `enum` | `StrictEnvType.Enum(choices)` | Value must be in `choices` (compared after trim). Trimmed by default. |
 
@@ -137,10 +159,30 @@ Evaluates every entry in `schema`. If any value is missing, empty without a defa
 
 - Trims leading/trailing whitespace before validation (default `trim: true`).
 - Parsed with `Number()`; the result must be finite (`NaN` and `Infinity` are rejected).
+- Optional constraints via `StrictEnvType.Number({ min, max, exclusiveMin, exclusiveMax, integer })`.
 - **Accepted examples**: `"3000"`, `"3.14"`, `"1e5"`, `"+42"`, `"0x10"`, `"  42  "`, `"-1"`
 - **Missing examples**: `""`, `"   "` (whitespace-only; `kind: 'missing'` unless a default is set)
 - **Rejected examples**: `"Infinity"`, `"NaN"`, `"not-a-number"`
 
+Named presets use those constraints (same parse path and `kind: 'invalid_number'`):
+
+| Preset | Constraints | Meaning |
+|--------|-------------|---------|
+| `Number.Integer` | `{ integer: true }` | Any integer |
+| `Number.PositiveInteger` | `{ min: 1, integer: true }` | Integer `>= 1` |
+| `Number.NegativeInteger` | `{ max: -1, integer: true }` | Integer `<= -1` |
+| `Number.NonNegativeInteger` | `{ min: 0, integer: true }` | Integer `>= 0` |
+| `Number.Positive` | `{ exclusiveMin: 0 }` | Finite number `> 0` |
+| `Number.Negative` | `{ exclusiveMax: 0 }` | Finite number `< 0` |
+| `Number.NonNegative` | `{ min: 0 }` | Finite number `>= 0` |
+| `Number.Port` | `{ min: 1, max: 65535, integer: true }` | Integer `1`–`65535` |
+
+```ts
+StrictEnvResolver.resolve('PORT', StrictEnvType.Number.Port);
+StrictEnvResolver.resolve('RATIO', StrictEnvType.Number.Positive);
+StrictEnvResolver.resolve('WORKERS', StrictEnvType.Number({ min: 1, max: 64, integer: true }));
+```
+
 ### Whitespace and trim
 
 | Spec | `trim` default | `""` | `"   "` (whitespace-only) | `" true "` |
@@ -165,13 +207,15 @@ StrictEnvResolver.resolve('PADDING', StrictEnvType.String, { trim: false });
 | `kind` | When |
 |--------|------|
 | `missing` | Variable unset, empty (`""`), or whitespace-only when trimming is enabled, without a default. |
-| `invalid_number` | Value is not a finite number. |
+| `invalid_number` | Value is not a finite number, not an integer when required, or outside `min` / `max` / `exclusiveMin` / `exclusiveMax`. |
 | `invalid_enum` | Value is not in `choices`. |
 
 **Message formats:**
 
 - Missing: `Missing required environment variable: <key>`
 - Number: `Env <key>: expected number, got "<raw>"`
+- Integer: `Env <key>: expected integer, got "<raw>"`
+- Bounds: `Env <key>: must be >= <min>, got <n>` (also `<=`, `>`, `<`)
 - Enum: `Env <key>: must be one of [choice1, choice2, ...]`
 
 `StrictEnvValidationError` fields:

package/lib/index.d.ts

@@ -9,21 +9,26 @@ export type StrictEnvTypeString = {
 };
 /**
  * Optional constraints for a numeric environment variable spec.
- * Used by {@link StrictEnvType.Number} when called as a factory, and by sugar specs
- * such as {@link StrictEnvType.PositiveInt} / {@link StrictEnvType.NegativeInt}.
+ * Used by {@link StrictEnvType.Number} when called as a factory, and by nested presets
+ * such as {@link StrictEnvType.Number.Port} / {@link StrictEnvType.Number.PositiveInteger}.
  */
 export type StrictEnvNumberConstraints = {
-    /** Inclusive lower bound. */
+    /** Inclusive lower bound (`n >= min`). */
     min?: number;
-    /** Inclusive upper bound. */
+    /** Inclusive upper bound (`n <= max`). */
     max?: number;
+    /** Exclusive lower bound (`n > exclusiveMin`). */
+    exclusiveMin?: number;
+    /** Exclusive upper bound (`n < exclusiveMax`). */
+    exclusiveMax?: number;
     /** When `true`, the value must be an integer (`Number.isInteger`). */
     integer?: boolean;
 };
 /**
  * Spec for a numeric environment variable.
  * Values are parsed with `Number()`; `NaN`, `Infinity`, and `-Infinity` are rejected.
- * Optional {@link StrictEnvNumberConstraints} (`min`, `max`, `integer`) narrow accepted values.
+ * Optional {@link StrictEnvNumberConstraints} (`min`, `max`, `exclusiveMin`, `exclusiveMax`, `integer`)
+ * narrow accepted values.
  * Defaults belong in {@link StrictEnvOptions}, not on this spec.
  */
 export type StrictEnvTypeNumber = {
@@ -57,8 +62,8 @@ export type StrictEnvSpec = StrictEnvTypeString | StrictEnvTypeNumber | StrictEn
  * Discriminated union of error kinds emitted during environment variable parsing.
  *
  * - `missing` — Variable unset, empty string, or whitespace-only (when trim is enabled) without a default.
- * - `invalid_number` — Value is not a finite number, not an integer when required, or outside `min`/`max`
- *   (see {@link StrictEnvTypeNumber}).
+ * - `invalid_number` — Value is not a finite number, not an integer when required, or outside
+ *   `min` / `max` / `exclusiveMin` / `exclusiveMax` (see {@link StrictEnvTypeNumber}).
  * - `invalid_enum` — Value is not one of the allowed enum choices.
  */
 export type StrictEnvErrorKind = 'missing' | 'invalid_number' | 'invalid_enum';
@@ -130,19 +135,44 @@ export declare class StrictEnvValidationError<K extends string = string> extends
      */
     constructor(errors: readonly StrictEnvValidationEntry<K>[]);
 }
+/**
+ * Named number presets nested under {@link StrictEnvType.Number}.
+ * Each preset is sugar over {@link StrictEnvNumberConstraints}; parsing stays `type: 'number'`.
+ */
+type StrictEnvNumberPresets = {
+    /** Any integer. Sugar for `Number({ integer: true })`. */
+    Integer: StrictEnvTypeNumber;
+    /** Integer `>= 1`. Sugar for `Number({ min: 1, integer: true })`. */
+    PositiveInteger: StrictEnvTypeNumber;
+    /** Integer `<= -1`. Sugar for `Number({ max: -1, integer: true })`. */
+    NegativeInteger: StrictEnvTypeNumber;
+    /** Integer `>= 0`. Sugar for `Number({ min: 0, integer: true })`. */
+    NonNegativeInteger: StrictEnvTypeNumber;
+    /** Finite number `> 0`. Sugar for `Number({ exclusiveMin: 0 })`. */
+    Positive: StrictEnvTypeNumber;
+    /** Finite number `< 0`. Sugar for `Number({ exclusiveMax: 0 })`. */
+    Negative: StrictEnvTypeNumber;
+    /** Finite number `>= 0`. Sugar for `Number({ min: 0 })`. */
+    NonNegative: StrictEnvTypeNumber;
+    /** TCP/UDP port `1`–`65535`. Sugar for `Number({ min: 1, max: 65535, integer: true })`. */
+    Port: StrictEnvTypeNumber;
+};
 /**
  * Unconstrained finite-number spec, also callable as a factory for constrained specs.
+ * Named presets hang off the same object (`Number.Port`, `Number.PositiveInteger`, …).
  *
  * @example
  * ```ts
  * StrictEnvType.Number
  * StrictEnvType.Number({ min: 0 })
- * StrictEnvType.Number({ min: 1, max: 65535, integer: true })
+ * StrictEnvType.Number({ exclusiveMin: 0 })
+ * StrictEnvType.Number.Port
+ * StrictEnvType.Number.PositiveInteger
  * ```
  */
 type StrictEnvNumberSpecFactory = {
     (constraints?: StrictEnvNumberConstraints): StrictEnvTypeNumber;
-} & StrictEnvTypeNumber;
+} & StrictEnvTypeNumber & StrictEnvNumberPresets;
 /**
  * Predefined spec constants for use with `resolve` or as schema values in `resolveAll`.
  * Specs describe type only; provide `default` / `trim` via {@link StrictEnvOptions}
@@ -155,17 +185,10 @@ export declare const StrictEnvType: {
     };
     /**
      * Spec for a finite numeric value (`Number()` parsing; rejects `NaN` and `Infinity`).
-     * Use as `StrictEnvType.Number`, or call as `StrictEnvType.Number({ min, max, integer })`.
+     * Use as `StrictEnvType.Number`, call as `StrictEnvType.Number({ min, max, exclusiveMin, exclusiveMax, integer })`,
+     * or use a nested preset such as `StrictEnvType.Number.Port`.
      */
     readonly Number: StrictEnvNumberSpecFactory;
-    /**
-     * Spec for a positive integer (`>= 1`). Sugar for `Number({ min: 1, integer: true })`.
-     */
-    readonly PositiveInt: StrictEnvTypeNumber;
-    /**
-     * Spec for a negative integer (`<= -1`). Sugar for `Number({ max: -1, integer: true })`.
-     */
-    readonly NegativeInt: StrictEnvTypeNumber;
     /** Spec for a boolean value (`1`/`true`/`yes`/`on` → `true`; other non-empty values → `false`). */
     readonly Boolean: {
         readonly type: "boolean";
@@ -230,9 +253,9 @@ export type StrictEnvSchemaToType<TSchema extends StrictEnvSchema> = {
  *
  * @example
  * ```ts
- * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.PositiveInt);
+ * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.Number.Port);
  * const envs = StrictEnvResolver.resolveAll({
- *   PORT: StrictEnvType.PositiveInt,
+ *   PORT: StrictEnvType.Number.Port,
  *   DEBUG: [StrictEnvType.Boolean, { default: false }],
  * });
  * ```

package/lib/index.js

@@ -85,19 +85,48 @@ class StrictEnvValidationError extends StrictEnvError {
     }
 }
 exports.StrictEnvValidationError = StrictEnvValidationError;
+/** Inclusive lower bound for positive integers (`>= 1`). */
+const MIN_POSITIVE_INTEGER = 1;
+/** Inclusive upper bound for negative integers (`<= -1`). */
+const MAX_NEGATIVE_INTEGER = -1;
+/**
+ * Sign boundary for Positive (`> 0`), Negative (`< 0`), and non-negative (`>= 0`) presets.
+ */
+const ZERO = 0;
+/**
+ * Inclusive lower TCP/UDP port (IANA). Port 0 means "any available" and is rejected.
+ */
+const MIN_PORT = MIN_POSITIVE_INTEGER;
+/** Inclusive upper TCP/UDP port (IANA). */
+const MAX_PORT = 65535;
 /**
  * Builds a numeric env spec from optional constraints.
  *
- * @param constraints - Optional `min`, `max`, and/or `integer` bounds.
+ * @param constraints - Optional `min`, `max`, `exclusiveMin`, `exclusiveMax`, and/or `integer` bounds.
  * @returns Number spec for use with `resolve` or `resolveAll`.
  */
 const createNumberSpec = (constraints) => ({
     type: 'number',
     ...(constraints?.min !== undefined ? { min: constraints.min } : {}),
     ...(constraints?.max !== undefined ? { max: constraints.max } : {}),
+    ...(constraints?.exclusiveMin !== undefined ? { exclusiveMin: constraints.exclusiveMin } : {}),
+    ...(constraints?.exclusiveMax !== undefined ? { exclusiveMax: constraints.exclusiveMax } : {}),
     ...(constraints?.integer !== undefined ? { integer: constraints.integer } : {}),
 });
-const NumberSpec = Object.assign((constraints) => createNumberSpec(constraints), { type: 'number' });
+/**
+ * Finite-number spec that is also a constraint factory and a holder of named presets.
+ * Use as `Number`, `Number({ min, max, exclusiveMin, exclusiveMax, integer })`, or `Number.Port`.
+ */
+const NumberSpec = Object.assign((constraints) => createNumberSpec(constraints), { type: 'number' }, {
+    Integer: createNumberSpec({ integer: true }),
+    PositiveInteger: createNumberSpec({ min: MIN_POSITIVE_INTEGER, integer: true }),
+    NegativeInteger: createNumberSpec({ max: MAX_NEGATIVE_INTEGER, integer: true }),
+    NonNegativeInteger: createNumberSpec({ min: ZERO, integer: true }),
+    Positive: createNumberSpec({ exclusiveMin: ZERO }),
+    Negative: createNumberSpec({ exclusiveMax: ZERO }),
+    NonNegative: createNumberSpec({ min: ZERO }),
+    Port: createNumberSpec({ min: MIN_PORT, max: MAX_PORT, integer: true }),
+});
 /**
  * Predefined spec constants for use with `resolve` or as schema values in `resolveAll`.
  * Specs describe type only; provide `default` / `trim` via {@link StrictEnvOptions}
@@ -108,17 +137,10 @@ exports.StrictEnvType = {
     String: { type: 'string' },
     /**
      * Spec for a finite numeric value (`Number()` parsing; rejects `NaN` and `Infinity`).
-     * Use as `StrictEnvType.Number`, or call as `StrictEnvType.Number({ min, max, integer })`.
+     * Use as `StrictEnvType.Number`, call as `StrictEnvType.Number({ min, max, exclusiveMin, exclusiveMax, integer })`,
+     * or use a nested preset such as `StrictEnvType.Number.Port`.
      */
     Number: NumberSpec,
-    /**
-     * Spec for a positive integer (`>= 1`). Sugar for `Number({ min: 1, integer: true })`.
-     */
-    PositiveInt: createNumberSpec({ min: 1, integer: true }),
-    /**
-     * Spec for a negative integer (`<= -1`). Sugar for `Number({ max: -1, integer: true })`.
-     */
-    NegativeInt: createNumberSpec({ max: -1, integer: true }),
     /** Spec for a boolean value (`1`/`true`/`yes`/`on` → `true`; other non-empty values → `false`). */
     Boolean: { type: 'boolean' },
     /**
@@ -160,10 +182,11 @@ const normalizeEnvRaw = (raw, trim) => {
  * @param key - Environment variable name.
  * @param raw - Raw value from `process.env`, if present.
  * @param n - Parsed finite number.
- * @param constraints - Optional `min`, `max`, and/or `integer` constraints.
+ * @param constraints - Optional `min`, `max`, `exclusiveMin`, `exclusiveMax`, and/or `integer` constraints.
  * @returns `undefined` when valid; otherwise a structured validation error.
  */
 const validateNumberConstraints = (key, raw, n, constraints) => {
+    // Integer first so e.g. Port `80.5` reports "expected integer", not a range error.
     if (constraints.integer === true && !Number.isInteger(n)) {
         return { key, message: `Env ${key}: expected integer, got "${raw}"`, raw, kind: 'invalid_number' };
     }
@@ -175,6 +198,14 @@ const validateNumberConstraints = (key, raw, n, constraints) => {
             kind: 'invalid_number',
         };
     }
+    if (constraints.exclusiveMin !== undefined && n <= constraints.exclusiveMin) {
+        return {
+            key,
+            message: `Env ${key}: must be > ${constraints.exclusiveMin}, got ${n}`,
+            raw,
+            kind: 'invalid_number',
+        };
+    }
     if (constraints.max !== undefined && n > constraints.max) {
         return {
             key,
@@ -183,6 +214,14 @@ const validateNumberConstraints = (key, raw, n, constraints) => {
             kind: 'invalid_number',
         };
     }
+    if (constraints.exclusiveMax !== undefined && n >= constraints.exclusiveMax) {
+        return {
+            key,
+            message: `Env ${key}: must be < ${constraints.exclusiveMax}, got ${n}`,
+            raw,
+            kind: 'invalid_number',
+        };
+    }
     return undefined;
 };
 /**
@@ -203,7 +242,8 @@ const resolveSchemaEntry = (entry) => ({
  *
  * Missing or empty (`""`) values use `defaultValue` when provided. When `trim` is enabled,
  * whitespace-only values are treated as empty. Number specs delegate to `parseNumber`, then
- * optional `min` / `max` / `integer` constraints (see {@link StrictEnvNumberConstraints}).
+ * optional `min` / `max` / `exclusiveMin` / `exclusiveMax` / `integer` constraints
+ * (see {@link StrictEnvNumberConstraints}).
  * Boolean specs treat `1`/`true`/`yes`/`on` (case-insensitive, after normalization) as `true`.
  * Enum specs require an exact match in `choices` (after normalization).
  *
@@ -322,9 +362,9 @@ const resolveAll = (schema) => {
  *
  * @example
  * ```ts
- * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.PositiveInt);
+ * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.Number.Port);
  * const envs = StrictEnvResolver.resolveAll({
- *   PORT: StrictEnvType.PositiveInt,
+ *   PORT: StrictEnvType.Number.Port,
  *   DEBUG: [StrictEnvType.Boolean, { default: false }],
  * });
  * ```
@@ -335,4 +375,4 @@ exports.StrictEnvResolver = {
     /** Reads and parses multiple environment variables in one pass. See {@link resolveAll}. */
     resolveAll,
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Spec for a string environment variable.\n * Values are returned as-is unless `trim: true` is set in {@link StrictEnvOptions}\n * (whitespace-only values are then treated as missing).\n * Defaults belong in {@link StrictEnvOptions}, not on this spec.\n */\nexport type StrictEnvTypeString = { type: 'string' };\n\n/**\n * Optional constraints for a numeric environment variable spec.\n * Used by {@link StrictEnvType.Number} when called as a factory, and by sugar specs\n * such as {@link StrictEnvType.PositiveInt} / {@link StrictEnvType.NegativeInt}.\n */\nexport type StrictEnvNumberConstraints = {\n  /** Inclusive lower bound. */\n  min?: number;\n  /** Inclusive upper bound. */\n  max?: number;\n  /** When `true`, the value must be an integer (`Number.isInteger`). */\n  integer?: boolean;\n};\n\n/**\n * Spec for a numeric environment variable.\n * Values are parsed with `Number()`; `NaN`, `Infinity`, and `-Infinity` are rejected.\n * Optional {@link StrictEnvNumberConstraints} (`min`, `max`, `integer`) narrow accepted values.\n * Defaults belong in {@link StrictEnvOptions}, not on this spec.\n */\nexport type StrictEnvTypeNumber = { type: 'number' } & StrictEnvNumberConstraints;\n\n/**\n * Pattern for boolean env values that parse as `true`.\n * Matches `1`, `true`, `yes`, and `on` (case-insensitive) on the full trimmed string.\n */\nconst TRUE_BOOLEAN_PATTERN = /^(1|true|yes|on)$/i;\n\n/**\n * Parses a string as a finite number for environment variables.\n *\n * @param raw - Normalized environment variable value (trimmed when `trim` is enabled).\n * @returns Parsed number, or `undefined` when the value is not a finite number.\n */\nconst parseNumber = (raw: string): number | undefined => {\n  const n = Number(raw);\n  if (!Number.isFinite(n)) {\n    return undefined;\n  }\n  return n;\n};\n\n/**\n * Parses a normalized string as a boolean environment variable value.\n *\n * @param normalizedRaw - Normalized environment variable value (trimmed when `trim` is enabled).\n * @returns `true` for `1`/`true`/`yes`/`on` (case-insensitive); otherwise `false`.\n */\nconst parseBooleanEnvValue = (normalizedRaw: string): boolean => TRUE_BOOLEAN_PATTERN.test(normalizedRaw);\n\n/**\n * Spec for a boolean environment variable.\n * Parses `1`, `true`, `yes`, `on` (case-insensitive, after normalization) as `true`;\n * any other non-empty value as `false`.\n * Trims leading/trailing whitespace by default (see {@link StrictEnvOptions.trim}).\n * Defaults belong in {@link StrictEnvOptions}, not on this spec.\n */\nexport type StrictEnvTypeBoolean = { type: 'boolean' };\n\n/**\n * Spec for an enum environment variable with a fixed set of choices.\n * The value must be one of `choices` (compared after normalization); otherwise validation fails.\n * Trims leading/trailing whitespace by default (see {@link StrictEnvOptions.trim}).\n * Defaults belong in {@link StrictEnvOptions}, not on this spec.\n *\n * @template T - Literal string union of allowed values.\n */\nexport type StrictEnvTypeEnum<T extends string = string> = { type: 'enum'; choices: readonly T[] };\n\n/** Union of all environment variable spec types. */\nexport type StrictEnvSpec =\n  | StrictEnvTypeString\n  | StrictEnvTypeNumber\n  | StrictEnvTypeBoolean\n  | StrictEnvTypeEnum;\n\n/**\n * Discriminated union of error kinds emitted during environment variable parsing.\n *\n * - `missing` — Variable unset, empty string, or whitespace-only (when trim is enabled) without a default.\n * - `invalid_number` — Value is not a finite number, not an integer when required, or outside `min`/`max`\n *   (see {@link StrictEnvTypeNumber}).\n * - `invalid_enum` — Value is not one of the allowed enum choices.\n */\nexport type StrictEnvErrorKind = 'missing' | 'invalid_number' | 'invalid_enum';\n\n/**\n * A structured validation error entry for a single environment variable.\n *\n * @template K - Environment variable key type.\n */\nexport type StrictEnvValidationEntry<K extends string = string> = {\n  /** Environment variable name. */\n  key: K;\n  /** Human-readable error message. */\n  message: string;\n  /** Raw value from `process.env`, if present. */\n  raw?: string;\n  /** Error category for programmatic handling. */\n  kind: StrictEnvErrorKind;\n};\n\n/**\n * Base error class for this package.\n *\n * @example\n * ```ts\n * try {\n *   StrictEnvResolver.resolve('PORT', StrictEnvType.Number);\n * } catch (e) {\n *   if (e instanceof StrictEnvError) {\n *     // Handle all strict-env-resolver errors\n *   }\n * }\n * ```\n */\nexport abstract class StrictEnvError extends Error {\n  /**\n   * @param message - Error message.\n   */\n  protected constructor(message: string) {\n    super(message);\n    this.name = 'StrictEnvError';\n  }\n}\n\n/**\n * Validation error that carries one or more environment variable issues.\n *\n * Thrown by `StrictEnvResolver.resolve()` (single-entry `errors`) and\n * `StrictEnvResolver.resolveAll()` (multi-entry `errors`).\n * Individual entries are produced by the internal `parseEnvValue` helper.\n *\n * @template K - Union of environment variable keys included in `errors`.\n */\nexport class StrictEnvValidationError<K extends string = string> extends StrictEnvError {\n  /**\n   * Formats validation errors into a human-readable error message.\n   *\n   * @template K - Environment variable key type.\n   * @param errors - Validation error entries to format.\n   * @returns Multi-line summary listing each key and message.\n   */\n  public static format<K extends string>(errors: readonly StrictEnvValidationEntry<K>[]): string {\n    const lines = errors.map((e) => `- ${e.key}: ${e.message}${e.raw == null ? '' : ` (raw=\"${e.raw}\")`}`);\n    return `Invalid environment variables (${errors.length}):\\n${lines.join('\\n')}`;\n  }\n\n  /**\n   * Structured list of validation errors.\n   */\n  public readonly errors: readonly StrictEnvValidationEntry<K>[];\n  /**\n   * Convenience list of keys included in `errors`.\n   */\n  public readonly keys: readonly K[];\n\n  /**\n   * Creates a new validation error from one or more `StrictEnvValidationEntry` entries.\n   *\n   * @param errors - One or more structured validation errors.\n   */\n  public constructor(errors: readonly StrictEnvValidationEntry<K>[]) {\n    const msg = StrictEnvValidationError.format(errors);\n    super(msg);\n    this.name = 'StrictEnvValidationError';\n    this.errors = errors;\n    this.keys = errors.map((e) => e.key);\n  }\n}\n\n/**\n * Builds a numeric env spec from optional constraints.\n *\n * @param constraints - Optional `min`, `max`, and/or `integer` bounds.\n * @returns Number spec for use with `resolve` or `resolveAll`.\n */\nconst createNumberSpec = (constraints?: StrictEnvNumberConstraints): StrictEnvTypeNumber => ({\n  type: 'number',\n  ...(constraints?.min !== undefined ? { min: constraints.min } : {}),\n  ...(constraints?.max !== undefined ? { max: constraints.max } : {}),\n  ...(constraints?.integer !== undefined ? { integer: constraints.integer } : {}),\n});\n\n/**\n * Unconstrained finite-number spec, also callable as a factory for constrained specs.\n *\n * @example\n * ```ts\n * StrictEnvType.Number\n * StrictEnvType.Number({ min: 0 })\n * StrictEnvType.Number({ min: 1, max: 65535, integer: true })\n * ```\n */\ntype StrictEnvNumberSpecFactory = {\n  (constraints?: StrictEnvNumberConstraints): StrictEnvTypeNumber;\n} & StrictEnvTypeNumber;\n\nconst NumberSpec: StrictEnvNumberSpecFactory = Object.assign(\n  (constraints?: StrictEnvNumberConstraints): StrictEnvTypeNumber => createNumberSpec(constraints),\n  { type: 'number' } as const satisfies StrictEnvTypeNumber,\n);\n\n/**\n * Predefined spec constants for use with `resolve` or as schema values in `resolveAll`.\n * Specs describe type only; provide `default` / `trim` via {@link StrictEnvOptions}\n * (third argument of `resolve`, or a `[spec, options]` tuple in `resolveAll`).\n */\nexport const StrictEnvType = {\n  /** Spec for a string value (returned as-is unless `trim: true` is set in options). */\n  String: { type: 'string' } as const satisfies StrictEnvTypeString,\n  /**\n   * Spec for a finite numeric value (`Number()` parsing; rejects `NaN` and `Infinity`).\n   * Use as `StrictEnvType.Number`, or call as `StrictEnvType.Number({ min, max, integer })`.\n   */\n  Number: NumberSpec,\n  /**\n   * Spec for a positive integer (`>= 1`). Sugar for `Number({ min: 1, integer: true })`.\n   */\n  PositiveInt: createNumberSpec({ min: 1, integer: true }),\n  /**\n   * Spec for a negative integer (`<= -1`). Sugar for `Number({ max: -1, integer: true })`.\n   */\n  NegativeInt: createNumberSpec({ max: -1, integer: true }),\n  /** Spec for a boolean value (`1`/`true`/`yes`/`on` → `true`; other non-empty values → `false`). */\n  Boolean: { type: 'boolean' } as const satisfies StrictEnvTypeBoolean,\n  /**\n   * Returns a spec that restricts the value to one of the given choices.\n   *\n   * @param choices - Allowed string literals.\n   * @returns Enum spec for use with `resolve` or `resolveAll`.\n   */\n  Enum: <T extends string>(choices: readonly T[]) => ({ type: 'enum', choices }) as StrictEnvTypeEnum<T>,\n} as const;\n\n/**\n * Infers the return type from the given spec.\n * @template S - A `StrictEnvSpec` variant.\n */\nexport type StrictEnvSpecToType<S> =\n  S extends StrictEnvTypeString ? string\n    : S extends StrictEnvTypeNumber ? number\n      : S extends StrictEnvTypeBoolean ? boolean\n        : S extends StrictEnvTypeEnum<infer T> ? T\n          : never;\n\n/**\n * Options for reading an environment variable with an optional default.\n * Used as the third argument to `resolve` or as the second element of a `[spec, options]` tuple in `resolveAll`.\n *\n * `trim` defaults to `true` for `number`, `boolean`, and `enum` specs (whitespace-only values are\n * treated as missing). For `string` specs it defaults to `false` (values are returned as-is).\n *\n * @template S - Environment variable spec type.\n */\nexport type StrictEnvOptions<S extends StrictEnvSpec> = {\n  /** Fallback when the variable is unset, empty (`\"\"`), or whitespace-only (when `trim` is enabled). */\n  default?: StrictEnvSpecToType<S>;\n  /** When `true`, trims leading/trailing whitespace before validation. */\n  trim?: boolean;\n};\n\n/**\n * Schema entry for a single env var.\n *\n * Either a spec alone, or a `[spec, options]` tuple to attach {@link StrictEnvOptions}\n * (for example `default` and/or `trim`).\n */\nexport type StrictEnvSchemaEntry<S extends StrictEnvSpec = StrictEnvSpec> = S | readonly [S, StrictEnvOptions<S>];\n\n/**\n * Schema object used by `resolveAll()`.\n *\n * Keys are env var names; values are specs or `[spec, options]` tuples.\n */\nexport type StrictEnvSchema = Record<string, StrictEnvSchemaEntry>;\n\n/**\n * Extracts the spec type from a schema entry or `[spec, options]` tuple.\n *\n * @template E - Schema entry type.\n */\ntype StrictEnvSchemaEntryToSpec<E> = E extends readonly [infer S, unknown] ? S : E;\n\n/**\n * Maps a schema object to the resulting parsed environment object type.\n *\n * @template TSchema - Schema object type passed to `resolveAll`.\n */\nexport type StrictEnvSchemaToType<TSchema extends StrictEnvSchema> = {\n  [K in keyof TSchema]: StrictEnvSpecToType<StrictEnvSchemaEntryToSpec<TSchema[K]> & StrictEnvSpec>;\n};\n\n/**\n * Discriminated result of parsing a single environment variable.\n *\n * On success, `value` holds the parsed result. On failure, `error` holds a structured\n * `StrictEnvValidationEntry` entry (never throws).\n *\n * @template K - Environment variable key type.\n * @template S - Environment variable spec type.\n */\ntype ParseEnvValueResult<K extends string, S extends StrictEnvSpec> =\n  | { ok: true; value: StrictEnvSpecToType<S> }\n  | { ok: false; error: StrictEnvValidationEntry<K> };\n\n/**\n * Default trim behavior per spec type.\n * Parsed types trim by default; strings preserve the raw value unless opted in.\n *\n * @param spec - Environment variable spec.\n * @returns Whether leading/trailing whitespace should be trimmed before validation.\n */\nconst defaultTrimForSpec = (spec: StrictEnvSpec): boolean => spec.type !== 'string';\n\n/**\n * Normalizes a raw environment variable value before validation.\n *\n * @param raw - Raw value from `process.env`, if present.\n * @param trim - Whether to trim leading/trailing whitespace.\n * @returns Normalized value, or `undefined` when unset.\n */\nconst normalizeEnvRaw = (raw: string | undefined, trim: boolean): string | undefined => {\n  if (raw == null) {\n    return undefined;\n  }\n  if (!trim) {\n    return raw;\n  }\n  return raw.trim();\n};\n\n/**\n * Validates a parsed number against optional {@link StrictEnvNumberConstraints}.\n *\n * @template K - Environment variable key type.\n * @param key - Environment variable name.\n * @param raw - Raw value from `process.env`, if present.\n * @param n - Parsed finite number.\n * @param constraints - Optional `min`, `max`, and/or `integer` constraints.\n * @returns `undefined` when valid; otherwise a structured validation error.\n */\nconst validateNumberConstraints = <K extends string>(\n  key: K,\n  raw: string | undefined,\n  n: number,\n  constraints: StrictEnvNumberConstraints,\n): StrictEnvValidationEntry<K> | undefined => {\n  if (constraints.integer === true && !Number.isInteger(n)) {\n    return { key, message: `Env ${key}: expected integer, got \"${raw}\"`, raw, kind: 'invalid_number' };\n  }\n  if (constraints.min !== undefined && n < constraints.min) {\n    return {\n      key,\n      message: `Env ${key}: must be >= ${constraints.min}, got ${n}`,\n      raw,\n      kind: 'invalid_number',\n    };\n  }\n  if (constraints.max !== undefined && n > constraints.max) {\n    return {\n      key,\n      message: `Env ${key}: must be <= ${constraints.max}, got ${n}`,\n      raw,\n      kind: 'invalid_number',\n    };\n  }\n  return undefined;\n};\n\n/** Options accepted by `parseEnvValue` (subset of `StrictEnvOptions`). */\ntype ParseEnvValueOptions<S extends StrictEnvSpec> = Pick<StrictEnvOptions<S>, 'trim'>;\n\n/**\n * Resolves a schema entry into its spec and optional per-key options.\n *\n * @param entry - Schema entry or `[spec, options]` tuple.\n * @returns Parsed spec and options for `resolveAll`.\n */\nconst resolveSchemaEntry = (\n  entry: StrictEnvSchemaEntry,\n): { spec: StrictEnvSpec; options: StrictEnvOptions<StrictEnvSpec> | undefined } => ({\n  spec: (Array.isArray(entry) ? entry[0] : entry) as StrictEnvSpec,\n  options: (Array.isArray(entry) ? entry[1] : undefined) as StrictEnvOptions<StrictEnvSpec> | undefined,\n});\n\n/**\n * Parses a single environment variable according to the given spec.\n *\n * Central validation helper shared by `resolve` and `resolveAll`. Does not throw;\n * callers decide whether to throw immediately or collect errors.\n *\n * Missing or empty (`\"\"`) values use `defaultValue` when provided. When `trim` is enabled,\n * whitespace-only values are treated as empty. Number specs delegate to `parseNumber`, then\n * optional `min` / `max` / `integer` constraints (see {@link StrictEnvNumberConstraints}).\n * Boolean specs treat `1`/`true`/`yes`/`on` (case-insensitive, after normalization) as `true`.\n * Enum specs require an exact match in `choices` (after normalization).\n *\n * @template K - Environment variable key type.\n * @template S - Environment variable spec type.\n * @param key - Environment variable name.\n * @param spec - Type spec for the value.\n * @param raw - Raw value from `process.env`, if present.\n * @param defaultValue - Fallback from {@link StrictEnvOptions.default} when `raw` is missing or empty.\n * @param options - Optional trim override (`trim` defaults per spec type).\n * @returns Parsed value or a structured validation error.\n */\nconst parseEnvValue = <K extends string, S extends StrictEnvSpec>(\n  key: K,\n  spec: S,\n  raw: string | undefined,\n  defaultValue: StrictEnvSpecToType<S> | undefined,\n  options?: ParseEnvValueOptions<S>,\n): ParseEnvValueResult<K, S> => {\n  const trim = options?.trim ?? defaultTrimForSpec(spec);\n  const normalizedRaw = normalizeEnvRaw(raw, trim);\n  const hasDefault = defaultValue !== undefined;\n\n  if (normalizedRaw == null || normalizedRaw === '') {\n    if (hasDefault) {\n      return { ok: true, value: defaultValue as StrictEnvSpecToType<S> };\n    }\n    return {\n      ok: false,\n      error: { key, message: `Missing required environment variable: ${key}`, raw, kind: 'missing' },\n    };\n  }\n\n  switch (spec.type) {\n    case 'number': {\n      const n = parseNumber(normalizedRaw);\n      if (n === undefined) {\n        return {\n          ok: false,\n          error: { key, message: `Env ${key}: expected number, got \"${raw}\"`, raw, kind: 'invalid_number' },\n        };\n      }\n      const constraintError = validateNumberConstraints(key, raw, n, spec);\n      if (constraintError !== undefined) {\n        return { ok: false, error: constraintError };\n      }\n      return { ok: true, value: n as StrictEnvSpecToType<S> };\n    }\n    case 'boolean':\n      return { ok: true, value: parseBooleanEnvValue(normalizedRaw) as StrictEnvSpecToType<S> };\n    case 'enum':\n      if (!spec.choices.includes(normalizedRaw)) {\n        return {\n          ok: false,\n          error: {\n            key,\n            message: `Env ${key}: must be one of [${spec.choices.join(', ')}]`,\n            raw,\n            kind: 'invalid_enum',\n          },\n        };\n      }\n      return { ok: true, value: normalizedRaw as StrictEnvSpecToType<S> };\n    default:\n      return { ok: true, value: normalizedRaw as StrictEnvSpecToType<S> };\n  }\n};\n\n/**\n * Reads and parses an environment variable according to the given spec.\n *\n * Delegates validation to `parseEnvValue`. Missing or empty (`\"\"`) values use\n * `options.default` when provided; otherwise a `StrictEnvValidationError` is thrown.\n * Whitespace-only values are treated as missing when `trim` is enabled.\n * For `StrictEnvType.Number`, values are parsed as finite numbers (see {@link StrictEnvTypeNumber}).\n *\n * @template K - Environment variable key type.\n * @template S - Environment variable spec type.\n * @param key - Environment variable name (e.g. `\"PORT\"`, `\"NODE_ENV\"`).\n * @param spec - Type spec; defaults to `StrictEnvType.String` when omitted.\n * @param options - Optional `{ default, trim }`; see {@link StrictEnvOptions}.\n * @returns Parsed value with type inferred from `spec`.\n * @throws {StrictEnvValidationError} When the variable is missing, empty without a default,\n *   whitespace-only without a default (when trimming), or invalid for the spec.\n */\nconst resolve = <K extends string, S extends StrictEnvSpec = StrictEnvTypeString>(\n  key: K,\n  spec: S = StrictEnvType.String as S,\n  options?: StrictEnvOptions<S>,\n): StrictEnvSpecToType<S> => {\n  const result = parseEnvValue(key, spec, process.env[key], options?.default, options);\n  if (!result.ok) {\n    throw new StrictEnvValidationError([result.error]);\n  }\n  return result.value;\n};\n\n/**\n * Reads and parses multiple environment variables according to the given schema.\n *\n * Always evaluates every key in `schema`. Each entry is validated via `parseEnvValue`;\n * all errors are collected and thrown once in a single `StrictEnvValidationError`.\n * Number specs use the same finite-number rules as `resolve`.\n *\n * @template TSchema - Schema object type.\n * @param schema - Map of environment variable names to specs or `[spec, options]` tuples\n *   (see {@link StrictEnvOptions} for per-key `default` / `trim`).\n * @returns Parsed environment object with types inferred from the schema.\n * @throws {StrictEnvValidationError} When one or more variables are missing, empty without a default,\n *   whitespace-only without a default (when trimming), or invalid.\n */\nconst resolveAll = <TSchema extends StrictEnvSchema>(schema: TSchema): StrictEnvSchemaToType<TSchema> => {\n  const envs: Partial<StrictEnvSchemaToType<TSchema>> = {};\n  const errors: StrictEnvValidationEntry<Extract<keyof TSchema, string>>[] = [];\n\n  for (const key of Object.keys(schema) as Array<Extract<keyof TSchema, string>>) {\n    const { spec, options } = resolveSchemaEntry(schema[key]);\n\n    const result = parseEnvValue(key, spec, process.env[key], options?.default, options);\n    if (!result.ok) {\n      errors.push(result.error);\n      continue;\n    }\n    envs[key] = result.value as StrictEnvSchemaToType<TSchema>[typeof key];\n  }\n\n  if (errors.length > 0) throw new StrictEnvValidationError(errors);\n  return envs as StrictEnvSchemaToType<TSchema>;\n};\n\n/**\n * Type-safe environment variable resolver for Node.js `process.env`.\n *\n * @example\n * ```ts\n * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.PositiveInt);\n * const envs = StrictEnvResolver.resolveAll({\n *   PORT: StrictEnvType.PositiveInt,\n *   DEBUG: [StrictEnvType.Boolean, { default: false }],\n * });\n * ```\n */\nexport const StrictEnvResolver = {\n  /** Reads and parses a single environment variable. See {@link resolve}. */\n  resolve,\n  /** Reads and parses multiple environment variables in one pass. See {@link resolveAll}. */\n  resolveAll,\n} as const;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Spec for a string environment variable.\n * Values are returned as-is unless `trim: true` is set in {@link StrictEnvOptions}\n * (whitespace-only values are then treated as missing).\n * Defaults belong in {@link StrictEnvOptions}, not on this spec.\n */\nexport type StrictEnvTypeString = { type: 'string' };\n\n/**\n * Optional constraints for a numeric environment variable spec.\n * Used by {@link StrictEnvType.Number} when called as a factory, and by nested presets\n * such as {@link StrictEnvType.Number.Port} / {@link StrictEnvType.Number.PositiveInteger}.\n */\nexport type StrictEnvNumberConstraints = {\n  /** Inclusive lower bound (`n >= min`). */\n  min?: number;\n  /** Inclusive upper bound (`n <= max`). */\n  max?: number;\n  /** Exclusive lower bound (`n > exclusiveMin`). */\n  exclusiveMin?: number;\n  /** Exclusive upper bound (`n < exclusiveMax`). */\n  exclusiveMax?: number;\n  /** When `true`, the value must be an integer (`Number.isInteger`). */\n  integer?: boolean;\n};\n\n/**\n * Spec for a numeric environment variable.\n * Values are parsed with `Number()`; `NaN`, `Infinity`, and `-Infinity` are rejected.\n * Optional {@link StrictEnvNumberConstraints} (`min`, `max`, `exclusiveMin`, `exclusiveMax`, `integer`)\n * narrow accepted values.\n * Defaults belong in {@link StrictEnvOptions}, not on this spec.\n */\nexport type StrictEnvTypeNumber = { type: 'number' } & StrictEnvNumberConstraints;\n\n/**\n * Pattern for boolean env values that parse as `true`.\n * Matches `1`, `true`, `yes`, and `on` (case-insensitive) on the full trimmed string.\n */\nconst TRUE_BOOLEAN_PATTERN = /^(1|true|yes|on)$/i;\n\n/**\n * Parses a string as a finite number for environment variables.\n *\n * @param raw - Normalized environment variable value (trimmed when `trim` is enabled).\n * @returns Parsed number, or `undefined` when the value is not a finite number.\n */\nconst parseNumber = (raw: string): number | undefined => {\n  const n = Number(raw);\n  if (!Number.isFinite(n)) {\n    return undefined;\n  }\n  return n;\n};\n\n/**\n * Parses a normalized string as a boolean environment variable value.\n *\n * @param normalizedRaw - Normalized environment variable value (trimmed when `trim` is enabled).\n * @returns `true` for `1`/`true`/`yes`/`on` (case-insensitive); otherwise `false`.\n */\nconst parseBooleanEnvValue = (normalizedRaw: string): boolean => TRUE_BOOLEAN_PATTERN.test(normalizedRaw);\n\n/**\n * Spec for a boolean environment variable.\n * Parses `1`, `true`, `yes`, `on` (case-insensitive, after normalization) as `true`;\n * any other non-empty value as `false`.\n * Trims leading/trailing whitespace by default (see {@link StrictEnvOptions.trim}).\n * Defaults belong in {@link StrictEnvOptions}, not on this spec.\n */\nexport type StrictEnvTypeBoolean = { type: 'boolean' };\n\n/**\n * Spec for an enum environment variable with a fixed set of choices.\n * The value must be one of `choices` (compared after normalization); otherwise validation fails.\n * Trims leading/trailing whitespace by default (see {@link StrictEnvOptions.trim}).\n * Defaults belong in {@link StrictEnvOptions}, not on this spec.\n *\n * @template T - Literal string union of allowed values.\n */\nexport type StrictEnvTypeEnum<T extends string = string> = { type: 'enum'; choices: readonly T[] };\n\n/** Union of all environment variable spec types. */\nexport type StrictEnvSpec =\n  | StrictEnvTypeString\n  | StrictEnvTypeNumber\n  | StrictEnvTypeBoolean\n  | StrictEnvTypeEnum;\n\n/**\n * Discriminated union of error kinds emitted during environment variable parsing.\n *\n * - `missing` — Variable unset, empty string, or whitespace-only (when trim is enabled) without a default.\n * - `invalid_number` — Value is not a finite number, not an integer when required, or outside\n *   `min` / `max` / `exclusiveMin` / `exclusiveMax` (see {@link StrictEnvTypeNumber}).\n * - `invalid_enum` — Value is not one of the allowed enum choices.\n */\nexport type StrictEnvErrorKind = 'missing' | 'invalid_number' | 'invalid_enum';\n\n/**\n * A structured validation error entry for a single environment variable.\n *\n * @template K - Environment variable key type.\n */\nexport type StrictEnvValidationEntry<K extends string = string> = {\n  /** Environment variable name. */\n  key: K;\n  /** Human-readable error message. */\n  message: string;\n  /** Raw value from `process.env`, if present. */\n  raw?: string;\n  /** Error category for programmatic handling. */\n  kind: StrictEnvErrorKind;\n};\n\n/**\n * Base error class for this package.\n *\n * @example\n * ```ts\n * try {\n *   StrictEnvResolver.resolve('PORT', StrictEnvType.Number);\n * } catch (e) {\n *   if (e instanceof StrictEnvError) {\n *     // Handle all strict-env-resolver errors\n *   }\n * }\n * ```\n */\nexport abstract class StrictEnvError extends Error {\n  /**\n   * @param message - Error message.\n   */\n  protected constructor(message: string) {\n    super(message);\n    this.name = 'StrictEnvError';\n  }\n}\n\n/**\n * Validation error that carries one or more environment variable issues.\n *\n * Thrown by `StrictEnvResolver.resolve()` (single-entry `errors`) and\n * `StrictEnvResolver.resolveAll()` (multi-entry `errors`).\n * Individual entries are produced by the internal `parseEnvValue` helper.\n *\n * @template K - Union of environment variable keys included in `errors`.\n */\nexport class StrictEnvValidationError<K extends string = string> extends StrictEnvError {\n  /**\n   * Formats validation errors into a human-readable error message.\n   *\n   * @template K - Environment variable key type.\n   * @param errors - Validation error entries to format.\n   * @returns Multi-line summary listing each key and message.\n   */\n  public static format<K extends string>(errors: readonly StrictEnvValidationEntry<K>[]): string {\n    const lines = errors.map((e) => `- ${e.key}: ${e.message}${e.raw == null ? '' : ` (raw=\"${e.raw}\")`}`);\n    return `Invalid environment variables (${errors.length}):\\n${lines.join('\\n')}`;\n  }\n\n  /**\n   * Structured list of validation errors.\n   */\n  public readonly errors: readonly StrictEnvValidationEntry<K>[];\n  /**\n   * Convenience list of keys included in `errors`.\n   */\n  public readonly keys: readonly K[];\n\n  /**\n   * Creates a new validation error from one or more `StrictEnvValidationEntry` entries.\n   *\n   * @param errors - One or more structured validation errors.\n   */\n  public constructor(errors: readonly StrictEnvValidationEntry<K>[]) {\n    const msg = StrictEnvValidationError.format(errors);\n    super(msg);\n    this.name = 'StrictEnvValidationError';\n    this.errors = errors;\n    this.keys = errors.map((e) => e.key);\n  }\n}\n\n/** Inclusive lower bound for positive integers (`>= 1`). */\nconst MIN_POSITIVE_INTEGER = 1;\n\n/** Inclusive upper bound for negative integers (`<= -1`). */\nconst MAX_NEGATIVE_INTEGER = -1;\n\n/**\n * Sign boundary for Positive (`> 0`), Negative (`< 0`), and non-negative (`>= 0`) presets.\n */\nconst ZERO = 0;\n\n/**\n * Inclusive lower TCP/UDP port (IANA). Port 0 means \"any available\" and is rejected.\n */\nconst MIN_PORT = MIN_POSITIVE_INTEGER;\n\n/** Inclusive upper TCP/UDP port (IANA). */\nconst MAX_PORT = 65535;\n\n/**\n * Builds a numeric env spec from optional constraints.\n *\n * @param constraints - Optional `min`, `max`, `exclusiveMin`, `exclusiveMax`, and/or `integer` bounds.\n * @returns Number spec for use with `resolve` or `resolveAll`.\n */\nconst createNumberSpec = (constraints?: StrictEnvNumberConstraints): StrictEnvTypeNumber => ({\n  type: 'number',\n  ...(constraints?.min !== undefined ? { min: constraints.min } : {}),\n  ...(constraints?.max !== undefined ? { max: constraints.max } : {}),\n  ...(constraints?.exclusiveMin !== undefined ? { exclusiveMin: constraints.exclusiveMin } : {}),\n  ...(constraints?.exclusiveMax !== undefined ? { exclusiveMax: constraints.exclusiveMax } : {}),\n  ...(constraints?.integer !== undefined ? { integer: constraints.integer } : {}),\n});\n\n/**\n * Named number presets nested under {@link StrictEnvType.Number}.\n * Each preset is sugar over {@link StrictEnvNumberConstraints}; parsing stays `type: 'number'`.\n */\ntype StrictEnvNumberPresets = {\n  /** Any integer. Sugar for `Number({ integer: true })`. */\n  Integer: StrictEnvTypeNumber;\n  /** Integer `>= 1`. Sugar for `Number({ min: 1, integer: true })`. */\n  PositiveInteger: StrictEnvTypeNumber;\n  /** Integer `<= -1`. Sugar for `Number({ max: -1, integer: true })`. */\n  NegativeInteger: StrictEnvTypeNumber;\n  /** Integer `>= 0`. Sugar for `Number({ min: 0, integer: true })`. */\n  NonNegativeInteger: StrictEnvTypeNumber;\n  /** Finite number `> 0`. Sugar for `Number({ exclusiveMin: 0 })`. */\n  Positive: StrictEnvTypeNumber;\n  /** Finite number `< 0`. Sugar for `Number({ exclusiveMax: 0 })`. */\n  Negative: StrictEnvTypeNumber;\n  /** Finite number `>= 0`. Sugar for `Number({ min: 0 })`. */\n  NonNegative: StrictEnvTypeNumber;\n  /** TCP/UDP port `1`–`65535`. Sugar for `Number({ min: 1, max: 65535, integer: true })`. */\n  Port: StrictEnvTypeNumber;\n};\n\n/**\n * Unconstrained finite-number spec, also callable as a factory for constrained specs.\n * Named presets hang off the same object (`Number.Port`, `Number.PositiveInteger`, …).\n *\n * @example\n * ```ts\n * StrictEnvType.Number\n * StrictEnvType.Number({ min: 0 })\n * StrictEnvType.Number({ exclusiveMin: 0 })\n * StrictEnvType.Number.Port\n * StrictEnvType.Number.PositiveInteger\n * ```\n */\ntype StrictEnvNumberSpecFactory = {\n  (constraints?: StrictEnvNumberConstraints): StrictEnvTypeNumber;\n} & StrictEnvTypeNumber & StrictEnvNumberPresets;\n\n/**\n * Finite-number spec that is also a constraint factory and a holder of named presets.\n * Use as `Number`, `Number({ min, max, exclusiveMin, exclusiveMax, integer })`, or `Number.Port`.\n */\nconst NumberSpec: StrictEnvNumberSpecFactory = Object.assign(\n  (constraints?: StrictEnvNumberConstraints): StrictEnvTypeNumber => createNumberSpec(constraints),\n  { type: 'number' } as const satisfies StrictEnvTypeNumber,\n  {\n    Integer: createNumberSpec({ integer: true }),\n    PositiveInteger: createNumberSpec({ min: MIN_POSITIVE_INTEGER, integer: true }),\n    NegativeInteger: createNumberSpec({ max: MAX_NEGATIVE_INTEGER, integer: true }),\n    NonNegativeInteger: createNumberSpec({ min: ZERO, integer: true }),\n\n    Positive: createNumberSpec({ exclusiveMin: ZERO }),\n    Negative: createNumberSpec({ exclusiveMax: ZERO }),\n    NonNegative: createNumberSpec({ min: ZERO }),\n\n    Port: createNumberSpec({ min: MIN_PORT, max: MAX_PORT, integer: true }),\n  } as const satisfies StrictEnvNumberPresets,\n);\n\n/**\n * Predefined spec constants for use with `resolve` or as schema values in `resolveAll`.\n * Specs describe type only; provide `default` / `trim` via {@link StrictEnvOptions}\n * (third argument of `resolve`, or a `[spec, options]` tuple in `resolveAll`).\n */\nexport const StrictEnvType = {\n  /** Spec for a string value (returned as-is unless `trim: true` is set in options). */\n  String: { type: 'string' } as const satisfies StrictEnvTypeString,\n  /**\n   * Spec for a finite numeric value (`Number()` parsing; rejects `NaN` and `Infinity`).\n   * Use as `StrictEnvType.Number`, call as `StrictEnvType.Number({ min, max, exclusiveMin, exclusiveMax, integer })`,\n   * or use a nested preset such as `StrictEnvType.Number.Port`.\n   */\n  Number: NumberSpec,\n  /** Spec for a boolean value (`1`/`true`/`yes`/`on` → `true`; other non-empty values → `false`). */\n  Boolean: { type: 'boolean' } as const satisfies StrictEnvTypeBoolean,\n  /**\n   * Returns a spec that restricts the value to one of the given choices.\n   *\n   * @param choices - Allowed string literals.\n   * @returns Enum spec for use with `resolve` or `resolveAll`.\n   */\n  Enum: <T extends string>(choices: readonly T[]) => ({ type: 'enum', choices }) as StrictEnvTypeEnum<T>,\n} as const;\n\n/**\n * Infers the return type from the given spec.\n * @template S - A `StrictEnvSpec` variant.\n */\nexport type StrictEnvSpecToType<S> =\n  S extends StrictEnvTypeString ? string\n    : S extends StrictEnvTypeNumber ? number\n      : S extends StrictEnvTypeBoolean ? boolean\n        : S extends StrictEnvTypeEnum<infer T> ? T\n          : never;\n\n/**\n * Options for reading an environment variable with an optional default.\n * Used as the third argument to `resolve` or as the second element of a `[spec, options]` tuple in `resolveAll`.\n *\n * `trim` defaults to `true` for `number`, `boolean`, and `enum` specs (whitespace-only values are\n * treated as missing). For `string` specs it defaults to `false` (values are returned as-is).\n *\n * @template S - Environment variable spec type.\n */\nexport type StrictEnvOptions<S extends StrictEnvSpec> = {\n  /** Fallback when the variable is unset, empty (`\"\"`), or whitespace-only (when `trim` is enabled). */\n  default?: StrictEnvSpecToType<S>;\n  /** When `true`, trims leading/trailing whitespace before validation. */\n  trim?: boolean;\n};\n\n/**\n * Schema entry for a single env var.\n *\n * Either a spec alone, or a `[spec, options]` tuple to attach {@link StrictEnvOptions}\n * (for example `default` and/or `trim`).\n */\nexport type StrictEnvSchemaEntry<S extends StrictEnvSpec = StrictEnvSpec> = S | readonly [S, StrictEnvOptions<S>];\n\n/**\n * Schema object used by `resolveAll()`.\n *\n * Keys are env var names; values are specs or `[spec, options]` tuples.\n */\nexport type StrictEnvSchema = Record<string, StrictEnvSchemaEntry>;\n\n/**\n * Extracts the spec type from a schema entry or `[spec, options]` tuple.\n *\n * @template E - Schema entry type.\n */\ntype StrictEnvSchemaEntryToSpec<E> = E extends readonly [infer S, unknown] ? S : E;\n\n/**\n * Maps a schema object to the resulting parsed environment object type.\n *\n * @template TSchema - Schema object type passed to `resolveAll`.\n */\nexport type StrictEnvSchemaToType<TSchema extends StrictEnvSchema> = {\n  [K in keyof TSchema]: StrictEnvSpecToType<StrictEnvSchemaEntryToSpec<TSchema[K]> & StrictEnvSpec>;\n};\n\n/**\n * Discriminated result of parsing a single environment variable.\n *\n * On success, `value` holds the parsed result. On failure, `error` holds a structured\n * `StrictEnvValidationEntry` entry (never throws).\n *\n * @template K - Environment variable key type.\n * @template S - Environment variable spec type.\n */\ntype ParseEnvValueResult<K extends string, S extends StrictEnvSpec> =\n  | { ok: true; value: StrictEnvSpecToType<S> }\n  | { ok: false; error: StrictEnvValidationEntry<K> };\n\n/**\n * Default trim behavior per spec type.\n * Parsed types trim by default; strings preserve the raw value unless opted in.\n *\n * @param spec - Environment variable spec.\n * @returns Whether leading/trailing whitespace should be trimmed before validation.\n */\nconst defaultTrimForSpec = (spec: StrictEnvSpec): boolean => spec.type !== 'string';\n\n/**\n * Normalizes a raw environment variable value before validation.\n *\n * @param raw - Raw value from `process.env`, if present.\n * @param trim - Whether to trim leading/trailing whitespace.\n * @returns Normalized value, or `undefined` when unset.\n */\nconst normalizeEnvRaw = (raw: string | undefined, trim: boolean): string | undefined => {\n  if (raw == null) {\n    return undefined;\n  }\n  if (!trim) {\n    return raw;\n  }\n  return raw.trim();\n};\n\n/**\n * Validates a parsed number against optional {@link StrictEnvNumberConstraints}.\n *\n * @template K - Environment variable key type.\n * @param key - Environment variable name.\n * @param raw - Raw value from `process.env`, if present.\n * @param n - Parsed finite number.\n * @param constraints - Optional `min`, `max`, `exclusiveMin`, `exclusiveMax`, and/or `integer` constraints.\n * @returns `undefined` when valid; otherwise a structured validation error.\n */\nconst validateNumberConstraints = <K extends string>(\n  key: K,\n  raw: string | undefined,\n  n: number,\n  constraints: StrictEnvNumberConstraints,\n): StrictEnvValidationEntry<K> | undefined => {\n  // Integer first so e.g. Port `80.5` reports \"expected integer\", not a range error.\n  if (constraints.integer === true && !Number.isInteger(n)) {\n    return { key, message: `Env ${key}: expected integer, got \"${raw}\"`, raw, kind: 'invalid_number' };\n  }\n\n  if (constraints.min !== undefined && n < constraints.min) {\n    return {\n      key,\n      message: `Env ${key}: must be >= ${constraints.min}, got ${n}`,\n      raw,\n      kind: 'invalid_number',\n    };\n  }\n\n  if (constraints.exclusiveMin !== undefined && n <= constraints.exclusiveMin) {\n    return {\n      key,\n      message: `Env ${key}: must be > ${constraints.exclusiveMin}, got ${n}`,\n      raw,\n      kind: 'invalid_number',\n    };\n  }\n\n  if (constraints.max !== undefined && n > constraints.max) {\n    return {\n      key,\n      message: `Env ${key}: must be <= ${constraints.max}, got ${n}`,\n      raw,\n      kind: 'invalid_number',\n    };\n  }\n\n  if (constraints.exclusiveMax !== undefined && n >= constraints.exclusiveMax) {\n    return {\n      key,\n      message: `Env ${key}: must be < ${constraints.exclusiveMax}, got ${n}`,\n      raw,\n      kind: 'invalid_number',\n    };\n  }\n\n  return undefined;\n};\n\n/** Options accepted by `parseEnvValue` (subset of `StrictEnvOptions`). */\ntype ParseEnvValueOptions<S extends StrictEnvSpec> = Pick<StrictEnvOptions<S>, 'trim'>;\n\n/**\n * Resolves a schema entry into its spec and optional per-key options.\n *\n * @param entry - Schema entry or `[spec, options]` tuple.\n * @returns Parsed spec and options for `resolveAll`.\n */\nconst resolveSchemaEntry = (\n  entry: StrictEnvSchemaEntry,\n): { spec: StrictEnvSpec; options: StrictEnvOptions<StrictEnvSpec> | undefined } => ({\n  spec: (Array.isArray(entry) ? entry[0] : entry) as StrictEnvSpec,\n  options: (Array.isArray(entry) ? entry[1] : undefined) as StrictEnvOptions<StrictEnvSpec> | undefined,\n});\n\n/**\n * Parses a single environment variable according to the given spec.\n *\n * Central validation helper shared by `resolve` and `resolveAll`. Does not throw;\n * callers decide whether to throw immediately or collect errors.\n *\n * Missing or empty (`\"\"`) values use `defaultValue` when provided. When `trim` is enabled,\n * whitespace-only values are treated as empty. Number specs delegate to `parseNumber`, then\n * optional `min` / `max` / `exclusiveMin` / `exclusiveMax` / `integer` constraints\n * (see {@link StrictEnvNumberConstraints}).\n * Boolean specs treat `1`/`true`/`yes`/`on` (case-insensitive, after normalization) as `true`.\n * Enum specs require an exact match in `choices` (after normalization).\n *\n * @template K - Environment variable key type.\n * @template S - Environment variable spec type.\n * @param key - Environment variable name.\n * @param spec - Type spec for the value.\n * @param raw - Raw value from `process.env`, if present.\n * @param defaultValue - Fallback from {@link StrictEnvOptions.default} when `raw` is missing or empty.\n * @param options - Optional trim override (`trim` defaults per spec type).\n * @returns Parsed value or a structured validation error.\n */\nconst parseEnvValue = <K extends string, S extends StrictEnvSpec>(\n  key: K,\n  spec: S,\n  raw: string | undefined,\n  defaultValue: StrictEnvSpecToType<S> | undefined,\n  options?: ParseEnvValueOptions<S>,\n): ParseEnvValueResult<K, S> => {\n  const trim = options?.trim ?? defaultTrimForSpec(spec);\n  const normalizedRaw = normalizeEnvRaw(raw, trim);\n  const hasDefault = defaultValue !== undefined;\n\n  if (normalizedRaw == null || normalizedRaw === '') {\n    if (hasDefault) {\n      return { ok: true, value: defaultValue as StrictEnvSpecToType<S> };\n    }\n    return {\n      ok: false,\n      error: { key, message: `Missing required environment variable: ${key}`, raw, kind: 'missing' },\n    };\n  }\n\n  switch (spec.type) {\n    case 'number': {\n      const n = parseNumber(normalizedRaw);\n      if (n === undefined) {\n        return {\n          ok: false,\n          error: { key, message: `Env ${key}: expected number, got \"${raw}\"`, raw, kind: 'invalid_number' },\n        };\n      }\n      const constraintError = validateNumberConstraints(key, raw, n, spec);\n      if (constraintError !== undefined) {\n        return { ok: false, error: constraintError };\n      }\n      return { ok: true, value: n as StrictEnvSpecToType<S> };\n    }\n    case 'boolean':\n      return { ok: true, value: parseBooleanEnvValue(normalizedRaw) as StrictEnvSpecToType<S> };\n    case 'enum':\n      if (!spec.choices.includes(normalizedRaw)) {\n        return {\n          ok: false,\n          error: {\n            key,\n            message: `Env ${key}: must be one of [${spec.choices.join(', ')}]`,\n            raw,\n            kind: 'invalid_enum',\n          },\n        };\n      }\n      return { ok: true, value: normalizedRaw as StrictEnvSpecToType<S> };\n    default:\n      return { ok: true, value: normalizedRaw as StrictEnvSpecToType<S> };\n  }\n};\n\n/**\n * Reads and parses an environment variable according to the given spec.\n *\n * Delegates validation to `parseEnvValue`. Missing or empty (`\"\"`) values use\n * `options.default` when provided; otherwise a `StrictEnvValidationError` is thrown.\n * Whitespace-only values are treated as missing when `trim` is enabled.\n * For `StrictEnvType.Number`, values are parsed as finite numbers (see {@link StrictEnvTypeNumber}).\n *\n * @template K - Environment variable key type.\n * @template S - Environment variable spec type.\n * @param key - Environment variable name (e.g. `\"PORT\"`, `\"NODE_ENV\"`).\n * @param spec - Type spec; defaults to `StrictEnvType.String` when omitted.\n * @param options - Optional `{ default, trim }`; see {@link StrictEnvOptions}.\n * @returns Parsed value with type inferred from `spec`.\n * @throws {StrictEnvValidationError} When the variable is missing, empty without a default,\n *   whitespace-only without a default (when trimming), or invalid for the spec.\n */\nconst resolve = <K extends string, S extends StrictEnvSpec = StrictEnvTypeString>(\n  key: K,\n  spec: S = StrictEnvType.String as S,\n  options?: StrictEnvOptions<S>,\n): StrictEnvSpecToType<S> => {\n  const result = parseEnvValue(key, spec, process.env[key], options?.default, options);\n  if (!result.ok) {\n    throw new StrictEnvValidationError([result.error]);\n  }\n  return result.value;\n};\n\n/**\n * Reads and parses multiple environment variables according to the given schema.\n *\n * Always evaluates every key in `schema`. Each entry is validated via `parseEnvValue`;\n * all errors are collected and thrown once in a single `StrictEnvValidationError`.\n * Number specs use the same finite-number rules as `resolve`.\n *\n * @template TSchema - Schema object type.\n * @param schema - Map of environment variable names to specs or `[spec, options]` tuples\n *   (see {@link StrictEnvOptions} for per-key `default` / `trim`).\n * @returns Parsed environment object with types inferred from the schema.\n * @throws {StrictEnvValidationError} When one or more variables are missing, empty without a default,\n *   whitespace-only without a default (when trimming), or invalid.\n */\nconst resolveAll = <TSchema extends StrictEnvSchema>(schema: TSchema): StrictEnvSchemaToType<TSchema> => {\n  const envs: Partial<StrictEnvSchemaToType<TSchema>> = {};\n  const errors: StrictEnvValidationEntry<Extract<keyof TSchema, string>>[] = [];\n\n  for (const key of Object.keys(schema) as Array<Extract<keyof TSchema, string>>) {\n    const { spec, options } = resolveSchemaEntry(schema[key]);\n\n    const result = parseEnvValue(key, spec, process.env[key], options?.default, options);\n    if (!result.ok) {\n      errors.push(result.error);\n      continue;\n    }\n    envs[key] = result.value as StrictEnvSchemaToType<TSchema>[typeof key];\n  }\n\n  if (errors.length > 0) throw new StrictEnvValidationError(errors);\n  return envs as StrictEnvSchemaToType<TSchema>;\n};\n\n/**\n * Type-safe environment variable resolver for Node.js `process.env`.\n *\n * @example\n * ```ts\n * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.Number.Port);\n * const envs = StrictEnvResolver.resolveAll({\n *   PORT: StrictEnvType.Number.Port,\n *   DEBUG: [StrictEnvType.Boolean, { default: false }],\n * });\n * ```\n */\nexport const StrictEnvResolver = {\n  /** Reads and parses a single environment variable. See {@link resolve}. */\n  resolve,\n  /** Reads and parses multiple environment variables in one pass. See {@link resolveAll}. */\n  resolveAll,\n} as const;\n"]}

package/package.json

@@ -70,7 +70,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.6.6",
+  "version": "0.7.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [