strict-env-resolver 0.5.4 → 0.6.0

package/.devcontainer/devcontainer.json

@@ -1,14 +1,15 @@
 {
   "name": "dev-strict-env-resolver",
-  "image": "mcr.microsoft.com/devcontainers/base:bookworm",
+  "image": "mcr.microsoft.com/devcontainers/base:trixie",
   "features": {
     "ghcr.io/devcontainers/features/common-utils:2": {
       "username": "developer",
       "upgradePackages": true
     },
     "ghcr.io/devcontainers/features/git:1": {},
-    "ghcr.io/devcontainers/features/node:1": {
-      "version": "24"
+    "ghcr.io/devcontainers/features/node:2": {
+      "version": "24",
+      "npmVersion": "12"
     }
   },
   "workspaceMount": "source=${localWorkspaceFolder},target=/workspace,type=bind",

package/lib/index.d.ts

@@ -1,44 +1,55 @@
 /**
  * Spec for a string environment variable.
- * Returned as-is by default (`trim` defaults to `false`). Set `trim: true` in options to trim
- * whitespace and treat whitespace-only values as missing.
- * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.
+ * Values are returned as-is unless `trim: true` is set in {@link StrictEnvOptions}
+ * (whitespace-only values are then treated as missing).
+ * Defaults belong in {@link StrictEnvOptions}, not on this spec.
  */
 export type StrictEnvTypeString = {
     type: 'string';
-    default?: string;
+};
+/**
+ * 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}.
+ */
+export type StrictEnvNumberConstraints = {
+    /** Inclusive lower bound. */
+    min?: number;
+    /** Inclusive upper bound. */
+    max?: 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.
- * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.
+ * Optional {@link StrictEnvNumberConstraints} (`min`, `max`, `integer`) narrow accepted values.
+ * Defaults belong in {@link StrictEnvOptions}, not on this spec.
  */
 export type StrictEnvTypeNumber = {
     type: 'number';
-    default?: number;
-};
+} & StrictEnvNumberConstraints;
 /**
  * Spec for a boolean environment variable.
- * Parses `1`, `true`, `yes`, `on` (case-insensitive, after trim) as `true`; any other non-empty value as `false`.
- * Trims leading/trailing whitespace by default (see `StrictEnvOptions.trim`).
- * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.
+ * Parses `1`, `true`, `yes`, `on` (case-insensitive, after normalization) as `true`;
+ * any other non-empty value as `false`.
+ * Trims leading/trailing whitespace by default (see {@link StrictEnvOptions.trim}).
+ * Defaults belong in {@link StrictEnvOptions}, not on this spec.
  */
 export type StrictEnvTypeBoolean = {
     type: 'boolean';
-    default?: boolean;
 };
 /**
  * Spec for an enum environment variable with a fixed set of choices.
- * The value must be one of `choices` (compared after trim); otherwise validation fails.
- * Trims leading/trailing whitespace by default (see `StrictEnvOptions.trim`).
- * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.
+ * The value must be one of `choices` (compared after normalization); otherwise validation fails.
+ * Trims leading/trailing whitespace by default (see {@link StrictEnvOptions.trim}).
+ * Defaults belong in {@link StrictEnvOptions}, not on this spec.
  *
  * @template T - Literal string union of allowed values.
  */
 export type StrictEnvTypeEnum<T extends string = string> = {
     type: 'enum';
     choices: readonly T[];
-    default?: T;
 };
 /** Union of all environment variable spec types. */
 export type StrictEnvSpec = StrictEnvTypeString | StrictEnvTypeNumber | StrictEnvTypeBoolean | StrictEnvTypeEnum;
@@ -46,7 +57,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 (see `StrictEnvTypeNumber`).
+ * - `invalid_number` — Value is not a finite number, not an integer when required, or outside `min`/`max`
+ *   (see {@link StrictEnvTypeNumber}).
  * - `invalid_enum` — Value is not one of the allowed enum choices.
  */
 export type StrictEnvErrorKind = 'missing' | 'invalid_number' | 'invalid_enum';
@@ -118,9 +130,23 @@ export declare class StrictEnvValidationError<K extends string = string> extends
      */
     constructor(errors: readonly StrictEnvValidationEntry<K>[]);
 }
+/**
+ * Unconstrained finite-number spec, also callable as a factory for constrained specs.
+ *
+ * @example
+ * ```ts
+ * StrictEnvType.Number
+ * StrictEnvType.Number({ min: 0 })
+ * StrictEnvType.Number({ min: 1, max: 65535, integer: true })
+ * ```
+ */
+type StrictEnvNumberSpecFactory = {
+    (constraints?: StrictEnvNumberConstraints): StrictEnvTypeNumber;
+} & StrictEnvTypeNumber;
 /**
  * Predefined spec constants for use with `resolve` or as schema values in `resolveAll`.
- * Provide defaults via the third argument of `resolve` or a `[spec, { default }]` tuple in `resolveAll`.
+ * Specs describe type only; provide `default` / `trim` via {@link StrictEnvOptions}
+ * (third argument of `resolve`, or a `[spec, options]` tuple in `resolveAll`).
  */
 export declare const StrictEnvType: {
     /** Spec for a string value (returned as-is unless `trim: true` is set in options). */
@@ -129,10 +155,17 @@ 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 })`.
      */
-    readonly Number: {
-        readonly type: "number";
-    };
+    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";
@@ -160,6 +193,7 @@ export type StrictEnvSpecToType<S> = S extends StrictEnvTypeString ? string : S
  * @template S - Environment variable spec type.
  */
 export type StrictEnvOptions<S extends StrictEnvSpec> = {
+    /** Fallback when the variable is unset, empty (`""`), or whitespace-only (when `trim` is enabled). */
     default?: StrictEnvSpecToType<S>;
     /** When `true`, trims leading/trailing whitespace before validation. */
     trim?: boolean;
@@ -167,13 +201,14 @@ export type StrictEnvOptions<S extends StrictEnvSpec> = {
 /**
  * Schema entry for a single env var.
  *
- * Either provide a spec directly, or a tuple of `[spec, options]` to attach a default.
+ * Either a spec alone, or a `[spec, options]` tuple to attach {@link StrictEnvOptions}
+ * (for example `default` and/or `trim`).
  */
 export type StrictEnvSchemaEntry<S extends StrictEnvSpec = StrictEnvSpec> = S | readonly [S, StrictEnvOptions<S>];
 /**
  * Schema object used by `resolveAll()`.
  *
- * Keys are env var names, values are specs (optionally with defaults).
+ * Keys are env var names; values are specs or `[spec, options]` tuples.
  */
 export type StrictEnvSchema = Record<string, StrictEnvSchemaEntry>;
 /**
@@ -195,9 +230,9 @@ export type StrictEnvSchemaToType<TSchema extends StrictEnvSchema> = {
  *
  * @example
  * ```ts
- * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.Number);
+ * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.PositiveInt);
  * const envs = StrictEnvResolver.resolveAll({
- *   PORT: StrictEnvType.Number,
+ *   PORT: StrictEnvType.PositiveInt,
  *   DEBUG: [StrictEnvType.Boolean, { default: false }],
  * });
  * ```

package/lib/index.js

@@ -9,7 +9,7 @@ const TRUE_BOOLEAN_PATTERN = /^(1|true|yes|on)$/i;
 /**
  * Parses a string as a finite number for environment variables.
  *
- * @param raw - Trimmed environment variable value.
+ * @param raw - Normalized environment variable value (trimmed when `trim` is enabled).
  * @returns Parsed number, or `undefined` when the value is not a finite number.
  */
 const parseNumber = (raw) => {
@@ -20,9 +20,9 @@ const parseNumber = (raw) => {
     return n;
 };
 /**
- * Parses a trimmed string as a boolean environment variable value.
+ * Parses a normalized string as a boolean environment variable value.
  *
- * @param normalizedRaw - Trimmed raw environment variable value.
+ * @param normalizedRaw - Normalized environment variable value (trimmed when `trim` is enabled).
  * @returns `true` for `1`/`true`/`yes`/`on` (case-insensitive); otherwise `false`.
  */
 const parseBooleanEnvValue = (normalizedRaw) => TRUE_BOOLEAN_PATTERN.test(normalizedRaw);
@@ -85,17 +85,40 @@ class StrictEnvValidationError extends StrictEnvError {
     }
 }
 exports.StrictEnvValidationError = StrictEnvValidationError;
+/**
+ * Builds a numeric env spec from optional constraints.
+ *
+ * @param constraints - Optional `min`, `max`, 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?.integer !== undefined ? { integer: constraints.integer } : {}),
+});
+const NumberSpec = Object.assign((constraints) => createNumberSpec(constraints), { type: 'number' });
 /**
  * Predefined spec constants for use with `resolve` or as schema values in `resolveAll`.
- * Provide defaults via the third argument of `resolve` or a `[spec, { default }]` tuple in `resolveAll`.
+ * Specs describe type only; provide `default` / `trim` via {@link StrictEnvOptions}
+ * (third argument of `resolve`, or a `[spec, options]` tuple in `resolveAll`).
  */
 exports.StrictEnvType = {
     /** Spec for a string value (returned as-is unless `trim: true` is set in options). */
     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 })`.
+     */
+    Number: NumberSpec,
+    /**
+     * Spec for a positive integer (`>= 1`). Sugar for `Number({ min: 1, integer: true })`.
      */
-    Number: { type: 'number' },
+    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' },
     /**
@@ -130,6 +153,38 @@ const normalizeEnvRaw = (raw, trim) => {
     }
     return raw.trim();
 };
+/**
+ * Validates a parsed number against optional {@link StrictEnvNumberConstraints}.
+ *
+ * @template K - Environment variable key type.
+ * @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.
+ * @returns `undefined` when valid; otherwise a structured validation error.
+ */
+const validateNumberConstraints = (key, raw, n, constraints) => {
+    if (constraints.integer === true && !Number.isInteger(n)) {
+        return { key, message: `Env ${key}: expected integer, got "${raw}"`, raw, kind: 'invalid_number' };
+    }
+    if (constraints.min !== undefined && n < constraints.min) {
+        return {
+            key,
+            message: `Env ${key}: must be >= ${constraints.min}, got ${n}`,
+            raw,
+            kind: 'invalid_number',
+        };
+    }
+    if (constraints.max !== undefined && n > constraints.max) {
+        return {
+            key,
+            message: `Env ${key}: must be <= ${constraints.max}, got ${n}`,
+            raw,
+            kind: 'invalid_number',
+        };
+    }
+    return undefined;
+};
 /**
  * Resolves a schema entry into its spec and optional per-key options.
  *
@@ -147,16 +202,17 @@ const resolveSchemaEntry = (entry) => ({
  * callers decide whether to throw immediately or collect errors.
  *
  * Missing or empty (`""`) values use `defaultValue` when provided. When `trim` is enabled,
- * whitespace-only values are treated as empty. Number specs delegate to `parseNumber`.
- * Boolean specs treat `1`/`true`/`yes`/`on` (case-insensitive, after trim) as `true`.
- * Enum specs require an exact match in `choices` (after trim).
+ * whitespace-only values are treated as empty. Number specs delegate to `parseNumber`, then
+ * optional `min` / `max` / `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).
  *
  * @template K - Environment variable key type.
  * @template S - Environment variable spec type.
  * @param key - Environment variable name.
  * @param spec - Type spec for the value.
  * @param raw - Raw value from `process.env`, if present.
- * @param defaultValue - Fallback when `raw` is missing or empty.
+ * @param defaultValue - Fallback from {@link StrictEnvOptions.default} when `raw` is missing or empty.
  * @param options - Optional trim override (`trim` defaults per spec type).
  * @returns Parsed value or a structured validation error.
  */
@@ -182,6 +238,10 @@ const parseEnvValue = (key, spec, raw, defaultValue, options) => {
                     error: { key, message: `Env ${key}: expected number, got "${raw}"`, raw, kind: 'invalid_number' },
                 };
             }
+            const constraintError = validateNumberConstraints(key, raw, n, spec);
+            if (constraintError !== undefined) {
+                return { ok: false, error: constraintError };
+            }
             return { ok: true, value: n };
         }
         case 'boolean':
@@ -208,7 +268,8 @@ const parseEnvValue = (key, spec, raw, defaultValue, options) => {
  *
  * Delegates validation to `parseEnvValue`. Missing or empty (`""`) values use
  * `options.default` when provided; otherwise a `StrictEnvValidationError` is thrown.
- * For `StrictEnvType.Number`, values are parsed as finite numbers (see `StrictEnvTypeNumber`).
+ * Whitespace-only values are treated as missing when `trim` is enabled.
+ * For `StrictEnvType.Number`, values are parsed as finite numbers (see {@link StrictEnvTypeNumber}).
  *
  * @template K - Environment variable key type.
  * @template S - Environment variable spec type.
@@ -216,7 +277,8 @@ const parseEnvValue = (key, spec, raw, defaultValue, options) => {
  * @param spec - Type spec; defaults to `StrictEnvType.String` when omitted.
  * @param options - Optional `{ default, trim }`; see {@link StrictEnvOptions}.
  * @returns Parsed value with type inferred from `spec`.
- * @throws {StrictEnvValidationError} When the variable is missing, empty without a default, or invalid for the spec.
+ * @throws {StrictEnvValidationError} When the variable is missing, empty without a default,
+ *   whitespace-only without a default (when trimming), or invalid for the spec.
  */
 const resolve = (key, spec = exports.StrictEnvType.String, options) => {
     const result = parseEnvValue(key, spec, process.env[key], options?.default, options);
@@ -233,9 +295,11 @@ const resolve = (key, spec = exports.StrictEnvType.String, options) => {
  * Number specs use the same finite-number rules as `resolve`.
  *
  * @template TSchema - Schema object type.
- * @param schema - Map of environment variable names to specs, optionally with per-key defaults via `[spec, { default }]`.
+ * @param schema - Map of environment variable names to specs or `[spec, options]` tuples
+ *   (see {@link StrictEnvOptions} for per-key `default` / `trim`).
  * @returns Parsed environment object with types inferred from the schema.
- * @throws {StrictEnvValidationError} When one or more variables are missing, empty without a default, or invalid.
+ * @throws {StrictEnvValidationError} When one or more variables are missing, empty without a default,
+ *   whitespace-only without a default (when trimming), or invalid.
  */
 const resolveAll = (schema) => {
     const envs = {};
@@ -258,9 +322,9 @@ const resolveAll = (schema) => {
  *
  * @example
  * ```ts
- * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.Number);
+ * const port = StrictEnvResolver.resolve('PORT', StrictEnvType.PositiveInt);
  * const envs = StrictEnvResolver.resolveAll({
- *   PORT: StrictEnvType.Number,
+ *   PORT: StrictEnvType.PositiveInt,
  *   DEBUG: [StrictEnvType.Boolean, { default: false }],
  * });
  * ```
@@ -271,4 +335,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 * Returned as-is by default (`trim` defaults to `false`). Set `trim: true` in options to trim\n * whitespace and treat whitespace-only values as missing.\n * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.\n */\nexport type StrictEnvTypeString = { type: 'string'; default?: string };\n\n/**\n * Spec for a numeric environment variable.\n * Values are parsed with `Number()`; `NaN`, `Infinity`, and `-Infinity` are rejected.\n * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.\n */\nexport type StrictEnvTypeNumber = { type: 'number'; default?: number };\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 - Trimmed environment variable value.\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 trimmed string as a boolean environment variable value.\n *\n * @param normalizedRaw - Trimmed raw environment variable value.\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 trim) as `true`; any other non-empty value as `false`.\n * Trims leading/trailing whitespace by default (see `StrictEnvOptions.trim`).\n * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.\n */\nexport type StrictEnvTypeBoolean = { type: 'boolean'; default?: 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 trim); otherwise validation fails.\n * Trims leading/trailing whitespace by default (see `StrictEnvOptions.trim`).\n * The default value is passed via the third argument of `resolve` or a `[spec, options]` tuple in `resolveAll`, not in the spec.\n *\n * @template T - Literal string union of allowed values.\n */\nexport type StrictEnvTypeEnum<T extends string = string> = { type: 'enum'; choices: readonly T[]; default?: 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 (see `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 * Predefined spec constants for use with `resolve` or as schema values in `resolveAll`.\n * Provide defaults via the third argument of `resolve` or a `[spec, { default }]` 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   */\n  Number: { type: 'number' } as const satisfies StrictEnvTypeNumber,\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  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 provide a spec directly, or a tuple of `[spec, options]` to attach a default.\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 (optionally with defaults).\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/** 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`.\n * Boolean specs treat `1`/`true`/`yes`/`on` (case-insensitive, after trim) as `true`.\n * Enum specs require an exact match in `choices` (after trim).\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 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      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 * For `StrictEnvType.Number`, values are parsed as finite numbers (see `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, 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, optionally with per-key defaults via `[spec, { default }]`.\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, 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);\n * const envs = StrictEnvResolver.resolveAll({\n *   PORT: StrictEnvType.Number,\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 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"]}

package/package.json

@@ -44,10 +44,10 @@
     "eslint-plugin-import": "^2.32.0",
     "jest": "^30.4.2",
     "jest-junit": "^17",
-    "projen": "^0.101.20",
+    "projen": "^0.101.23",
     "ts-jest": "^29.4.12",
     "ts-node": "^10.9.2",
-    "typescript": "5.9.x"
+    "typescript": "6.0.x"
   },
   "keywords": [
     "env",
@@ -59,12 +59,18 @@
   "engines": {
     "node": ">= 20.0.0"
   },
+  "devEngines": {
+    "packageManager": {
+      "name": "npm",
+      "onFail": "ignore"
+    }
+  },
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.5.4",
+  "version": "0.6.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [