envapt 5.1.0 → 5.2.0-next.0

package/dist/browser/core/EnvapterBase.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvapterBase.mjs","names":[],"sources":["../../../src/core/EnvapterBase.ts"],"sourcesContent":["import { debugVerbose, getDebugLevel, setDebugLevel } from '../Debug';\nimport { loadDotenv } from '../Dotenv';\nimport { EnvaptError, EnvaptErrorCodes } from '../Error';\nimport { bindRuntimeFromSource } from '../runtime';\nimport { UnboundEnvSource } from '../sources/UnboundEnvSource';\nimport { Validator } from '../Validators';\n\nimport type { DebugLevel } from '../Debug';\nimport type { EnvFileOptions } from '../Dotenv';\nimport type { EnvKeyInput, EnvSource, FileEnvSource } from '../types';\n\n/** @internal */\nexport const EnvaptCache = new Map<string, unknown>();\n\n/** @internal */\nexport abstract class EnvapterBase {\n    protected static _envPaths: string[] = ['.env'];\n    protected static _envPathsExplicitlySet = false;\n    protected static _baseDir: string | undefined = undefined;\n    protected static _userDefinedEnvFileOptions: EnvFileOptions = {};\n    protected static _strict = false;\n    protected static _syncProcessEnv = false;\n    // Loader-written keys only (collisions skipped). Refilled on every cache rebuild.\n    protected static _dotenvAddedKeys: Set<string> = new Set<string>();\n    // Unbound by default so non-Node builds throw NoSourceBound on read until useSource() is called.\n    // NodeEnvapter's static block binds NodeEnvSource when referenced, so `import 'envapt'` needs no setup.\n    protected static _source: EnvSource = new UnboundEnvSource();\n\n    /**\n     * Enable or disable strict mode. Default `false`. Setting refreshes the cache so\n     * previously-cached converted values get re-evaluated under the new rule.\n     */\n    static set strict(value: boolean) {\n        // Anchored to EnvapterBase: `this._strict` would write an own-property on the subclass that base readers miss.\n        EnvapterBase._strict = value;\n        // `this`, not EnvapterBase: rebuild via the subclass so its `resolveEffectivePaths` override is honored.\n        this.refreshCache();\n    }\n\n    static get strict(): boolean {\n        return EnvapterBase._strict;\n    }\n\n    /**\n     * Set the debug log level. Defaults to `silent`. When unset, reads `ENVAPT_DEBUG` from the\n     * bound source on first access; the setter overrides any env-var value. Output goes to stderr\n     * on Node (the console elsewhere), prefixed with `[envapt]`.\n     */\n    static set debug(level: DebugLevel) {\n        setDebugLevel(level);\n    }\n\n    static get debug(): DebugLevel {\n        return getDebugLevel();\n    }\n\n    /**\n     * Opt-in mirror of dotenv-loaded keys back to `process.env`. Default `false`.\n     *\n     * Only keys the loader actually wrote are mirrored, so collision behavior follows\n     * `envFileOptions.override`: with the default `false`, pre-existing `process.env` values\n     * are preserved; with `true`, the file value wins in both the cache and the mirror.\n     *\n     * Flipping `false → true` mirrors the existing tracked delta immediately (no cache\n     * refresh). Flipping `true → false` is one-way: previously mirrored keys remain in\n     * `process.env` until the process exits.\n     */\n    static set syncProcessEnv(value: boolean) {\n        Validator.validateSyncProcessEnv(value);\n        const previous = EnvapterBase._syncProcessEnv;\n        // Anchored to EnvapterBase: `this._syncProcessEnv` would write an own-property on the subclass that base readers miss.\n        EnvapterBase._syncProcessEnv = value;\n        if (!previous && value && EnvaptCache.size > 0) this.mirrorToProcessEnv();\n    }\n\n    static get syncProcessEnv(): boolean {\n        return EnvapterBase._syncProcessEnv;\n    }\n\n    protected static treatAsMissing(value: string | undefined): boolean {\n        if (value === undefined || value === '') return true;\n        if (EnvapterBase._strict && value.trim() === '') return true;\n        return false;\n    }\n\n    // No baseDir: candidate returned unchanged so the source resolves it against its own default\n    // (process.cwd() on Node). Resolution goes through the source to keep this class node-free.\n    protected static resolveAgainstBase(candidate: string): string {\n        const baseDir = EnvapterBase._baseDir;\n        if (baseDir === undefined) return candidate;\n        const source = EnvapterBase._source;\n        /* v8 ignore next -- @preserve callers are all file-gated, so the source is never bare here */\n        if (!source.supportsFiles) return candidate;\n        return source.resolvePath(baseDir, candidate);\n    }\n\n    // File-based config (envPaths/baseDir/configureProfiles) is meaningless without a filesystem;\n    // throw instead of silently ignoring it on the browser or Workers. Narrows the source so callers\n    // can reach the file capabilities (resolvePath/normalizeBaseDir) after the check.\n    protected static assertFileApiSupported(api: string, source: EnvSource): asserts source is FileEnvSource {\n        if (!source.supportsFiles) {\n            throw new EnvaptError(\n                EnvaptErrorCodes.FileApiUnsupported,\n                `${api} requires a filesystem-backed source; the bound source does not support .env files.`\n            );\n        }\n    }\n\n    // Existence via the bound source instead of fs.existsSync/accessSync: a file \"exists\" when the\n    // source can read it.\n    protected static sourceFileExists(path: string): boolean {\n        const source = EnvapterBase._source;\n        /* v8 ignore next -- @preserve every caller is file-gated, so this never sees a bare source */\n        if (!source.supportsFiles) return false;\n        return source.readFile(path, 'utf8') !== undefined;\n    }\n\n    protected static refreshCache(): void {\n        EnvaptCache.clear();\n        EnvapterBase._dotenvAddedKeys = new Set();\n        debugVerbose('cache cleared, reloading config');\n        void this.config; // getter rebuilds the cache as a side effect\n    }\n\n    protected static mirrorToProcessEnv(): void {\n        if (EnvapterBase._dotenvAddedKeys.size === 0) return;\n        const source = EnvapterBase._source;\n        /* v8 ignore next -- @preserve dotenv keys only accumulate under a file source, so the delta implies supportsFiles here */\n        if (!source.supportsFiles) return;\n        const mirrored: Record<string, string> = {};\n        for (const key of EnvapterBase._dotenvAddedKeys) {\n            const value = EnvaptCache.get(key);\n            /* v8 ignore next -- @preserve loader only writes strings; defensive against future cache contents */\n            if (typeof value !== 'string') continue;\n            mirrored[key] = value;\n            debugVerbose(`mirrored ${key} to the ambient environment`);\n        }\n        source.writeVars(mirrored);\n        debugVerbose(`mirrored ${EnvapterBase._dotenvAddedKeys.size} keys to the ambient environment`);\n    }\n\n    // Default returns the explicit `_envPaths`; EnvironmentMethods overrides to layer the dotenv-flow\n    // cascade + configureProfiles when envPaths was never explicitly set.\n    protected static resolveEffectivePaths(): string[] {\n        /* v8 ignore next -- @preserve */\n        return this._envPaths.map((p) => this.resolveAgainstBase(p));\n    }\n\n    protected static resolveKeyInput(keyInput: EnvKeyInput): { key: string; value: string | undefined } {\n        const keys = Array.isArray(keyInput) ? keyInput : [keyInput];\n        const normalizedKeys = keys as readonly string[];\n\n        if (normalizedKeys.length === 0) {\n            throw new EnvaptError(EnvaptErrorCodes.InvalidKeyInput, 'At least one environment key must be provided.');\n        }\n\n        if (normalizedKeys.some((k) => typeof k !== 'string')) {\n            throw new EnvaptError(EnvaptErrorCodes.InvalidKeyInput, 'Environment keys must be strings.');\n        }\n\n        if (normalizedKeys.some((k) => k.trim() === '')) {\n            throw new EnvaptError(EnvaptErrorCodes.InvalidKeyInput, 'Environment keys cannot be empty strings.');\n        }\n\n        for (const candidate of normalizedKeys) {\n            const value = this.config.get(candidate) as string | undefined;\n            if (value !== undefined) {\n                return { key: candidate, value };\n            }\n        }\n\n        return { key: normalizedKeys[0] as string, value: undefined };\n    }\n\n    protected static get config(): Map<string, unknown> {\n        if (EnvaptCache.size === 0) {\n            const source = EnvapterBase._source;\n            // Clone so the loader and downstream reads never mutate the source's backing object.\n            const isolatedEnv: Record<string, string> = { ...source.readVars() };\n\n            let added = new Set<string>();\n            // Sources without a filesystem (injected objects on the browser or Workers) skip the\n            // .env cascade, profiles, and envPaths; only the readVars() snapshot populates the cache.\n            if (source.supportsFiles) {\n                // Outside the try below so a missing configured profile path surfaces its EnvaptError; only dotenv parse errors stay caught.\n                const effectivePaths = this.resolveEffectivePaths();\n                debugVerbose(\n                    `effective .env paths: ${effectivePaths.length === 0 ? '(none)' : effectivePaths.join(', ')}`\n                );\n                try {\n                    added = loadDotenv({\n                        ...this._userDefinedEnvFileOptions,\n                        path: effectivePaths,\n                        processEnv: isolatedEnv,\n                        readFile: source.readFile.bind(source)\n                    });\n                } catch {}\n            }\n            EnvapterBase._dotenvAddedKeys = added;\n            for (const [key, value] of Object.entries(isolatedEnv)) EnvaptCache.set(key, value);\n            debugVerbose(`cache populated: ${EnvaptCache.size} keys total`);\n            if (EnvapterBase._syncProcessEnv) this.mirrorToProcessEnv();\n        }\n\n        return EnvaptCache;\n    }\n\n    /**\n     * Eagerly load the `.env` cascade now instead of lazily on the first read. Idempotent: a no-op\n     * once the cache is built. Useful before mirroring to `process.env` (see {@link syncProcessEnv}),\n     * which is what the `envapt/config` side-effect entry does.\n     */\n    static load(): void {\n        void this.config;\n    }\n\n    /**\n     * Bind the environment {@link EnvSource}. On Node the entry binds {@link NodeEnvSource} for you\n     * (a `process.env` snapshot plus the `.env` cascade); on the browser or Workers, pass a\n     * `ManualEnvSource` / `WorkerEnvSource` (or any `EnvSource`) before reading. Clears and rebuilds\n     * the cache.\n     */\n    static useSource(source: EnvSource): void {\n        EnvapterBase._source = source;\n        bindRuntimeFromSource(source);\n        this.refreshCache();\n    }\n\n    /**\n     * Read an environment variable as its raw string, skipping parsing and conversion.\n     */\n    getRaw(key: EnvKeyInput): string | undefined {\n        return EnvapterBase.resolveKeyInput(key).value;\n    }\n}\n"],"mappings":"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"}

package/dist/{core → browser/core}/EnvironmentMethods.d.mts

@@ -1,5 +1,5 @@
-import { EnvapterBase } from "./EnvapterBase.mjs";
 import { ProfilesConfig } from "../types/Options.mjs";
+import { EnvapterBase } from "./EnvapterBase.mjs";
 
 //#region src/core/EnvironmentMethods.d.ts
 /**
@@ -9,7 +9,8 @@ import { ProfilesConfig } from "../types/Options.mjs";
 declare enum Environment {
   Development = 0,
   Staging = 1,
-  Production = 2
+  Production = 2,
+  Test = 3
 }
 /**
  * Mixin for environment detection and checking methods
@@ -20,7 +21,7 @@ declare class EnvironmentMethods extends EnvapterBase {
   protected static _environmentExplicitlySet: boolean;
   protected static _profiles: ProfilesConfig | undefined;
   protected static determineEnvironment(env?: string | Environment): void;
-  private static getRawValue;
+  private static firstEnvKeyValue;
   /**
    * Get the current application environment
    */
@@ -61,36 +62,18 @@ declare class EnvironmentMethods extends EnvapterBase {
    * @see {@link EnvironmentMethods.isDevelopment}
    */
   get isDevelopment(): boolean;
-  protected static refreshCache(): void;
   /**
-   * Configure per-environment `.env` path overrides on top of the dotenv-flow auto-cascade.
-   *
-   * When set, each `Environment` key's `paths` are loaded at higher precedence than the
-   * cascade for that environment. Unspecified environments still use the cascade as-is.
-   * Set `useDefaults: false` to disable the cascade entirely (load only the configured paths).
-   *
-   * Setting an explicit `Envapter.envPaths` value at any point overrides this configuration.
-   *
-   * @example
-   * ```ts
-   * Envapter.configureProfiles({
-   *   [Environment.Staging]: { paths: 'config/staging.env' },
-   *   [Environment.Production]: { paths: ['config/prod.env', 'secrets/prod.env'] }
-   * });
-   * ```
+   * Check if the current environment is test
    */
-  static configureProfiles(config: ProfilesConfig): void;
+  static get isTest(): boolean;
   /**
-   * Reset all path-resolution configuration to defaults: clears any prior
-   * {@link configureProfiles} call AND any explicit `Envapter.envPaths` assignment.
-   * Returns the resolver to the pure dotenv-flow cascade.
+   * @see {@link EnvironmentMethods.isTest}
    */
-  static resetProfiles(): void;
+  get isTest(): boolean;
+  protected static refreshCache(): void;
   /**
-   * Determine the current environment for cascade-file selection by reading `process.env`
-   * directly. Bypassing `this.config` to avoid a circular dependency (cascade selection
-   * happens before `.env` files are loaded). The post-load `Envapter.environment` value
-   * may differ if a loaded `.env` file declares its own `ENVIRONMENT`/`ENV`/`NODE_ENV`.
+   * Reads the source's raw vars (not `this.config`, which would recurse: cascade selection runs
+   * before the `.env` load). `Envapter.environment` may differ post-load if a file sets `ENVIRONMENT`.
    * @internal
    */
   protected static getCascadeEnvironment(): Environment;
@@ -111,7 +94,7 @@ declare class EnvironmentMethods extends EnvapterBase {
   private static normalizeProfilePaths;
   /**
    * Override the base implementation to layer the dotenv-flow cascade + any
-   * {@link configureProfiles} overrides on top of `_envPaths` when the user has NOT
+   * `Envapter.configureProfiles` overrides on top of `_envPaths` when the user has NOT
    * explicitly set `envPaths`.
    *
    * Precedence (passed to dotenv with first-wins semantics):
@@ -121,7 +104,7 @@ declare class EnvironmentMethods extends EnvapterBase {
    *   4. `.env.local`
    *   5. `.env`
    *
-   * If `useDefaults: false` is set on the profiles config, only (1) is loaded — no cascade.
+   * If `useDefaults: false` is set on the profiles config, only (1) is loaded, no cascade.
    * If `envPaths` was explicitly set, only `envPaths` is loaded (everything else ignored).
    * @internal
    */

package/dist/browser/core/EnvironmentMethods.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentMethods.d.mts","names":[],"sources":["../../../src/core/EnvironmentMethods.ts"],"mappings":";;;;;;AAUA;;aAAY,WAAA;EACR,WAAA;EACA,OAAA;EACA,UAAA;EACA,IAAA;AAAA;;AAAI;AAyBR;;cAAa,kBAAA,SAA2B,YAAA;EAAA,iBACnB,YAAA,EAAc,WAAA;EAAA,iBACd,yBAAA;EAAA,iBACA,SAAA,EAAW,cAAA;EAAA,iBAEX,oBAAA,CAAqB,GAAA,YAAe,WAAA;EAAA,eA8BtC,gBAAA;EA4BI;;;EAAA,WAjBR,WAAA,CAAA,GAAe,WAAA;EA9CU;;;EAAA,WAwDzB,WAAA,CAAY,GAAA,WAAc,WAAA;EAvDpB;;;EAAA,IA8Db,WAAA,CAAA,GAAe,WAAA;EA5DS;;;EAAA,IAmExB,WAAA,CAAY,GAAA,WAAc,WAAA;EAnCf;;;EAAA,WA0CJ,YAAA,CAAA;EArB0B;;;EAAA,IA4BjC,YAAA,CAAA;EAdA;;;EAAA,WAqBO,SAAA,CAAA;EAPP;;;EAAA,IAcA,SAAA,CAAA;EAcA;;;EAAA,WAPO,aAAA,CAAA;EAuCM;;;EAAA,IAhCb,aAAA,CAAA;EAqD+B;;;EAAA,WA9CxB,MAAA,CAAA;EA0EoC;;;EAAA,IAnE3C,MAAA,CAAA;EAAA,iBAIsB,YAAA,CAAA;;;;;;mBAcT,qBAAA,CAAA,GAAyB,WAAA;;;;;;;;;;;;;;mBAqBzB,iBAAA,CAAkB,GAAA,EAAK,WAAA;EAAA,eAOzB,qBAAA;;;;;;;;;;;;;;;;;mBAqBW,qBAAA,CAAA;AAAA"}

package/dist/browser/core/EnvironmentMethods.mjs

@@ -0,0 +1,2 @@
+import{EnvaptError as e}from"../Error.mjs";import{debugWarn as t}from"../Debug.mjs";import{EnvapterBase as n}from"./EnvapterBase.mjs";let r=function(e){return e[e.Development=0]=`Development`,e[e.Staging=1]=`Staging`,e[e.Production=2]=`Production`,e[e.Test=3]=`Test`,e}({});const i=[`ENVIRONMENT`,`ENV`,`NODE_ENV`,`MODE`];function a(e){switch(e.toLowerCase()){case`production`:return 2;case`staging`:return 1;case`test`:return 3;case`development`:return 0;default:return}}var o=class o extends n{static _environment;static _environmentExplicitlySet=!1;static _profiles;static determineEnvironment(e){if(typeof e==`number`){this._environment=e,this._environmentExplicitlySet=!0;return}if(typeof e==`string`){this._environment=a(e)??0,this._environmentExplicitlySet=!0;return}let n=this.firstEnvKeyValue(e=>{let t=this.config.get(e);return typeof t==`string`?t:void 0});if(n===void 0){t(`no environment set (looked for ${i.join(`, `)}); defaulting to development`),this._environment=0;return}let r=a(n);if(r===void 0){t(`unrecognized environment "${n}"; defaulting to development`),this._environment=0;return}this._environment=r}static firstEnvKeyValue(e){for(let t of i){let n=e(t);if(n!==void 0&&n.length>0)return n}}static get environment(){return this._environment===void 0&&this.determineEnvironment(),this._environment}static set environment(e){this.determineEnvironment(e)}get environment(){return o.environment}set environment(e){o.determineEnvironment(e)}static get isProduction(){return this.environment===2}get isProduction(){return o.environment===2}static get isStaging(){return this.environment===1}get isStaging(){return o.environment===1}static get isDevelopment(){return this.environment===0}get isDevelopment(){return o.environment===0}static get isTest(){return this.environment===3}get isTest(){return o.environment===3}static refreshCache(){this._environmentExplicitlySet||(this._environment=void 0),super.refreshCache()}static getCascadeEnvironment(){if(this._environment!==void 0)return this._environment;let e=n._source.readVars(),t=this.firstEnvKeyValue(t=>e[t]);return t===void 0?0:a(t)??0}static buildCascadePaths(e){let t=r[e].toLowerCase();return[`.env.${t}.local`,`.env.${t}`,`.env.local`,`.env`].map(e=>this.resolveAgainstBase(e)).filter(e=>this.sourceFileExists(e))}static normalizeProfilePaths(e){return e?Array.isArray(e.paths)?e.paths:[e.paths]:[]}static resolveEffectivePaths(){if(this._envPathsExplicitlySet)return this._envPaths.map(e=>this.resolveAgainstBase(e));let t=this.getCascadeEnvironment(),n=this._profiles?.[t],r=this.normalizeProfilePaths(n);if(r.length>0){let t=r.filter(e=>!this.sourceFileExists(this.resolveAgainstBase(e)));if(t.length>0)throw new e(303,`Environment file not found at path: ${t.join(`, `)}`)}let i=this._profiles?.useDefaults===!1?[]:this.buildCascadePaths(t);return[...r.map(e=>this.resolveAgainstBase(e)),...i]}};export{r as Environment,o as EnvironmentMethods};
+//# sourceMappingURL=EnvironmentMethods.mjs.map

package/dist/browser/core/EnvironmentMethods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentMethods.mjs","names":[],"sources":["../../../src/core/EnvironmentMethods.ts"],"sourcesContent":["import { debugWarn } from '../Debug';\nimport { EnvaptError, EnvaptErrorCodes } from '../Error';\nimport { EnvapterBase } from './EnvapterBase';\n\nimport type { EnvProfile, ProfilesConfig } from '../types';\n\n/**\n * Environment types supported by Envapter\n * @public\n */\nexport enum Environment {\n    Development,\n    Staging,\n    Production,\n    Test\n}\n\n// Keys carrying the environment name, highest precedence first. Checked in order until the first with a non-empty value is found, or defaulting to development if none are set.\nconst ENV_KEYS = ['ENVIRONMENT', 'ENV', 'NODE_ENV', 'MODE'] as const;\n\nfunction parseEnvironment(raw: string): Environment | undefined {\n    switch (raw.toLowerCase()) {\n        case 'production':\n            return Environment.Production;\n        case 'staging':\n            return Environment.Staging;\n        case 'test':\n            return Environment.Test;\n        case 'development':\n            return Environment.Development;\n        default:\n            return undefined;\n    }\n}\n\n/**\n * Mixin for environment detection and checking methods\n * @internal\n */\nexport class EnvironmentMethods extends EnvapterBase {\n    protected static _environment: Environment | undefined;\n    protected static _environmentExplicitlySet = false;\n    protected static _profiles: ProfilesConfig | undefined;\n\n    protected static determineEnvironment(env?: string | Environment): void {\n        if (typeof env === 'number') {\n            this._environment = env;\n            this._environmentExplicitlySet = true;\n            return;\n        }\n        if (typeof env === 'string') {\n            this._environment = parseEnvironment(env) ?? Environment.Development;\n            this._environmentExplicitlySet = true;\n            return;\n        }\n\n        const raw = this.firstEnvKeyValue((key) => {\n            const value = this.config.get(key);\n            return typeof value === 'string' ? value : undefined;\n        });\n        if (raw === undefined) {\n            debugWarn(`no environment set (looked for ${ENV_KEYS.join(', ')}); defaulting to development`);\n            this._environment = Environment.Development;\n            return;\n        }\n        const parsed = parseEnvironment(raw);\n        if (parsed === undefined) {\n            debugWarn(`unrecognized environment \"${raw}\"; defaulting to development`);\n            this._environment = Environment.Development;\n            return;\n        }\n        this._environment = parsed;\n    }\n\n    private static firstEnvKeyValue(read: (key: string) => string | undefined): string | undefined {\n        for (const key of ENV_KEYS) {\n            const value = read(key);\n            if (value !== undefined && value.length > 0) return value;\n        }\n        return undefined;\n    }\n\n    /**\n     * Get the current application environment\n     */\n    static get environment(): Environment {\n        if (this._environment === undefined) {\n            this.determineEnvironment();\n        }\n        return this._environment as Environment;\n    }\n\n    /**\n     * Set the application environment. Accepts either Environment enum or string value.\n     */\n    static set environment(env: string | Environment) {\n        this.determineEnvironment(env);\n    }\n\n    /**\n     * @see {@link EnvironmentMethods.environment}\n     */\n    get environment(): Environment {\n        return EnvironmentMethods.environment;\n    }\n\n    /**\n     * @see {@link EnvironmentMethods.environment}\n     */\n    set environment(env: string | Environment) {\n        EnvironmentMethods.determineEnvironment(env);\n    }\n\n    /**\n     * Check if the current environment is production\n     */\n    static get isProduction(): boolean {\n        return this.environment === Environment.Production;\n    }\n\n    /**\n     * @see {@link EnvironmentMethods.isProduction}\n     */\n    get isProduction(): boolean {\n        return EnvironmentMethods.environment === Environment.Production;\n    }\n\n    /**\n     * Check if the current environment is staging\n     */\n    static get isStaging(): boolean {\n        return this.environment === Environment.Staging;\n    }\n\n    /**\n     * @see {@link EnvironmentMethods.isStaging}\n     */\n    get isStaging(): boolean {\n        return EnvironmentMethods.environment === Environment.Staging;\n    }\n\n    /**\n     * Check if the current environment is development\n     */\n    static get isDevelopment(): boolean {\n        return this.environment === Environment.Development;\n    }\n\n    /**\n     * @see {@link EnvironmentMethods.isDevelopment}\n     */\n    get isDevelopment(): boolean {\n        return EnvironmentMethods.environment === Environment.Development;\n    }\n\n    /**\n     * Check if the current environment is test\n     */\n    static get isTest(): boolean {\n        return this.environment === Environment.Test;\n    }\n\n    /**\n     * @see {@link EnvironmentMethods.isTest}\n     */\n    get isTest(): boolean {\n        return EnvironmentMethods.environment === Environment.Test;\n    }\n\n    protected static override refreshCache(): void {\n        // If the env was inferred (not user-set), reset it so re-hydration re-determines\n        // from current state. If the user explicitly set Envapter.environment = X, preserve\n        // that value through the refresh. The immediate re-hydration inside super.refreshCache()\n        // will use it for cascade selection.\n        if (!this._environmentExplicitlySet) this._environment = undefined;\n        super.refreshCache();\n    }\n\n    /**\n     * Reads the source's raw vars (not `this.config`, which would recurse: cascade selection runs\n     * before the `.env` load). `Envapter.environment` may differ post-load if a file sets `ENVIRONMENT`.\n     * @internal\n     */\n    protected static getCascadeEnvironment(): Environment {\n        if (this._environment !== undefined) return this._environment;\n\n        const vars = EnvapterBase._source.readVars();\n        const raw = this.firstEnvKeyValue((key) => vars[key]);\n        return raw === undefined ? Environment.Development : (parseEnvironment(raw) ?? Environment.Development);\n    }\n\n    /**\n     * Build the dotenv-flow cascade for a given environment, in dotenv first-wins precedence\n     * order (highest precedence first). Missing files are silently filtered.\n     *\n     * Precedence is **most-specific-wins** (matches Vite / Astro / Vocs):\n     *   `.env.${env}.local` \\> `.env.${env}` \\> `.env.local` \\> `.env`\n     *\n     * This differs from dotenv-flow / Next.js convention which puts `.env.local` above\n     * `.env.${env}`. We chose the most-specific-wins order so committed env-specific files\n     * (`.env.production`) are authoritative for that environment regardless of whether a\n     * stray `.env.local` is present.\n     * @internal\n     */\n    protected static buildCascadePaths(env: Environment): string[] {\n        const envName = Environment[env].toLowerCase();\n        return [`.env.${envName}.local`, `.env.${envName}`, '.env.local', '.env']\n            .map((name) => this.resolveAgainstBase(name))\n            .filter((p) => this.sourceFileExists(p));\n    }\n\n    private static normalizeProfilePaths(profile: EnvProfile | undefined): string[] {\n        if (!profile) return [];\n        return Array.isArray(profile.paths) ? profile.paths : [profile.paths];\n    }\n\n    /**\n     * Override the base implementation to layer the dotenv-flow cascade + any\n     * `Envapter.configureProfiles` overrides on top of `_envPaths` when the user has NOT\n     * explicitly set `envPaths`.\n     *\n     * Precedence (passed to dotenv with first-wins semantics):\n     *   1. profile-configured paths for the current env (if any)\n     *   2. `.env.${env}.local`\n     *   3. `.env.${env}`\n     *   4. `.env.local`\n     *   5. `.env`\n     *\n     * If `useDefaults: false` is set on the profiles config, only (1) is loaded, no cascade.\n     * If `envPaths` was explicitly set, only `envPaths` is loaded (everything else ignored).\n     * @internal\n     */\n    protected static override resolveEffectivePaths(): string[] {\n        if (this._envPathsExplicitlySet) return this._envPaths.map((p) => this.resolveAgainstBase(p));\n\n        const env = this.getCascadeEnvironment();\n        const profileEntry = this._profiles?.[env];\n        const profilePaths = this.normalizeProfilePaths(profileEntry);\n\n        // Validate that explicitly configured profile paths exist for the active env.\n        if (profilePaths.length > 0) {\n            const missing = profilePaths.filter((p) => !this.sourceFileExists(this.resolveAgainstBase(p)));\n            if (missing.length > 0) {\n                throw new EnvaptError(\n                    EnvaptErrorCodes.EnvFilesNotFound,\n                    `Environment file not found at path: ${missing.join(', ')}`\n                );\n            }\n        }\n\n        const cascade = this._profiles?.useDefaults === false ? [] : this.buildCascadePaths(env);\n        return [...profilePaths.map((p) => this.resolveAgainstBase(p)), ...cascade];\n    }\n}\n"],"mappings":"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"}

package/dist/browser/core/PrimitiveMethods.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimitiveMethods.d.mts","names":[],"sources":["../../../src/core/PrimitiveMethods.ts"],"mappings":";;;;;;;;;AAuBA;cAAa,gBAAA,SAAyB,kBAAA,YAA8B,eAAA;EAAA,wBACxC,OAAA;EAAA,0BACE,gBAAA,EAAkB,gBAAA;EAAA,0BAClB,cAAA,EAAgB,cAAA;EAK1C,QAAA,CAAA;EAAA,eAIe,IAAA;EAmCc;;;;;EAAA,OAHtB,GAAA,gDAAA,CACH,GAAA,EAAK,WAAA,EACL,GAAA,GAAM,OAAA,GACP,iBAAA,SAA0B,OAAA;EAoBpB;;;EAbT,GAAA,gDAAA,CACI,GAAA,EAAK,WAAA,EACL,GAAA,GAAM,OAAA,GACP,iBAAA,SAA0B,OAAA;EAoBpB;;;;;EAAA,OAXF,SAAA,gDAAA,CACH,GAAA,EAAK,WAAA,EACL,GAAA,GAAM,OAAA,GACP,iBAAA,SAA0B,OAAA;EAsBC;;;EAf9B,SAAA,gDAAA,CACI,GAAA,EAAK,WAAA,EACL,GAAA,GAAM,OAAA,GACP,iBAAA,SAA0B,OAAA;EAsBC;;;;;EAAA,OAbvB,UAAA,iDAAA,CACH,GAAA,EAAK,WAAA,EACL,GAAA,GAAM,OAAA,GACP,iBAAA,UAA2B,OAAA;EA8BrB;;;EAvBT,UAAA,iDAAA,CACI,GAAA,EAAK,WAAA,EACL,GAAA,GAAM,OAAA,GACP,iBAAA,UAA2B,OAAA;EAgCrB;;;;;EAAA,OAvBF,SAAA,gDAAA,CACH,GAAA,EAAK,WAAA,EACL,GAAA,GAAM,OAAA,GACP,iBAAA,SAA0B,OAAA;EAgCA;;;EAzB7B,SAAA,gDAAA,CACI,GAAA,EAAK,WAAA,EACL,GAAA,GAAM,OAAA,GACP,iBAAA,SAA0B,OAAA;EA3HkD;;;;;EAAA,OAoIxE,SAAA,gDAAA,CACH,GAAA,EAAK,WAAA,EACL,GAAA,GAAM,OAAA,GACP,iBAAA,SAA0B,OAAA;EArIe;;;EA4I5C,SAAA,gDAAA,CACI,GAAA,EAAK,WAAA,EACL,GAAA,GAAM,OAAA,GACP,iBAAA,SAA0B,OAAA;AAAA"}

package/dist/browser/core/PrimitiveMethods.mjs

@@ -0,0 +1,2 @@
+import{debugWarn as e}from"../Debug.mjs";import{EnvapterBase as t}from"./EnvapterBase.mjs";import{EnvironmentMethods as n}from"./EnvironmentMethods.mjs";import{BuiltInConverters as r}from"../converters/BuiltInConverters.mjs";import{ValueConverter as i}from"../converters/ValueConverter.mjs";import{TemplateResolver as a}from"../TemplateResolver.mjs";var o=class o extends n{static service=new o;static templateResolver=new a(o.service);static valueConverter=new i(o.service);isStrict(){return t.strict}static _get(t,n,i){let{key:a,value:o}=this.resolveKeyInput(t);if(this.treatAsMissing(o))return i!==void 0&&e(`${a} not found, using fallback ${String(i)}`),i;let s=o,c=this.templateResolver.resolveTemplate(a,String(s)),l;return l=n===1?r.number(c,i):n===2?r.boolean(c,i):n===3?r.bigint(c,i):n===4?r.symbol(c,i):r.string(c,i),l}static get(e,t){return this._get(e,0,t)}get(e,t){return o._get(e,0,t)}static getNumber(e,t){return this._get(e,1,t)}getNumber(e,t){return o._get(e,1,t)}static getBoolean(e,t){return this._get(e,2,t)}getBoolean(e,t){return o._get(e,2,t)}static getBigInt(e,t){return this._get(e,3,t)}getBigInt(e,t){return o._get(e,3,t)}static getSymbol(e,t){return this._get(e,4,t)}getSymbol(e,t){return o._get(e,4,t)}};export{o as PrimitiveMethods};
+//# sourceMappingURL=PrimitiveMethods.mjs.map

package/dist/browser/core/PrimitiveMethods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimitiveMethods.mjs","names":[],"sources":["../../../src/core/PrimitiveMethods.ts"],"sourcesContent":["import { BuiltInConverters, ValueConverter } from '../converters';\nimport { debugWarn } from '../Debug';\nimport { TemplateResolver } from '../TemplateResolver';\nimport { EnvapterBase } from './EnvapterBase';\nimport { EnvironmentMethods } from './EnvironmentMethods';\n\nimport type { ConditionalReturn, EnvKeyInput } from '../types';\nimport type { EnvapterService } from '../types/Env';\n\n/**\n * @internal\n */\nenum Primitive {\n    String,\n    Number,\n    Boolean,\n    BigInt,\n    Symbol\n}\n\n/**\n * @internal\n */\nexport class PrimitiveMethods extends EnvironmentMethods implements EnvapterService {\n    private static readonly service = new PrimitiveMethods();\n    protected static readonly templateResolver: TemplateResolver = new TemplateResolver(PrimitiveMethods.service);\n    protected static readonly valueConverter: ValueConverter = new ValueConverter(PrimitiveMethods.service);\n\n    // Read `EnvapterBase.strict` directly: `PrimitiveMethods._strict` would resolve to the\n    // BaseClass default because a `Envapter.strict = true` write lands as an own-property\n    // on `Envapter`, which is a descendant of `PrimitiveMethods`, not an ancestor.\n    isStrict(): boolean {\n        return EnvapterBase.strict;\n    }\n\n    private static _get<EnvVarReturnType, DefaultType extends EnvVarReturnType | undefined = undefined>(\n        key: EnvKeyInput,\n        type: Primitive,\n        def?: DefaultType\n    ): ConditionalReturn<EnvVarReturnType, DefaultType> {\n        const { key: resolvedKey, value } = this.resolveKeyInput(key);\n        if (this.treatAsMissing(value)) {\n            if (def !== undefined) debugWarn(`${resolvedKey} not found, using fallback ${String(def)}`);\n            return def as ConditionalReturn<EnvVarReturnType, DefaultType>;\n        }\n        const rawVal = value as string | number | boolean | undefined;\n\n        const parsed = this.templateResolver.resolveTemplate(resolvedKey, String(rawVal));\n\n        let result: EnvVarReturnType;\n        if (type === Primitive.Number) result = BuiltInConverters.number(parsed, def as number) as EnvVarReturnType;\n        else if (type === Primitive.Boolean)\n            result = BuiltInConverters.boolean(parsed, def as boolean) as EnvVarReturnType;\n        else if (type === Primitive.BigInt)\n            result = BuiltInConverters.bigint(parsed, def as bigint) as EnvVarReturnType;\n        else if (type === Primitive.Symbol)\n            result = BuiltInConverters.symbol(parsed, def as symbol) as EnvVarReturnType;\n        else result = BuiltInConverters.string(parsed, def as string) as EnvVarReturnType;\n\n        return result as ConditionalReturn<EnvVarReturnType, DefaultType>;\n    }\n\n    /**\n     * Get a string environment variable with optional fallback.\n     * Supports template variable resolution using `${VAR}` syntax.\n     * Accepts a single key or an ordered array of keys (first match wins).\n     */\n    static get<Default extends string | undefined = undefined>(\n        key: EnvKeyInput,\n        def?: Default\n    ): ConditionalReturn<string, Default> {\n        return this._get(key, Primitive.String, def);\n    }\n\n    /**\n     * @see {@link PrimitiveMethods.get}\n     */\n    get<Default extends string | undefined = undefined>(\n        key: EnvKeyInput,\n        def?: Default\n    ): ConditionalReturn<string, Default> {\n        return PrimitiveMethods._get(key, Primitive.String, def);\n    }\n\n    /**\n     * Get a number environment variable with optional fallback.\n     * Automatically converts string values to numbers.\n     * Accepts a single key or an ordered array of keys (first match wins).\n     */\n    static getNumber<Default extends number | undefined = undefined>(\n        key: EnvKeyInput,\n        def?: Default\n    ): ConditionalReturn<number, Default> {\n        return this._get(key, Primitive.Number, def);\n    }\n\n    /**\n     * @see {@link PrimitiveMethods.getNumber}\n     */\n    getNumber<Default extends number | undefined = undefined>(\n        key: EnvKeyInput,\n        def?: Default\n    ): ConditionalReturn<number, Default> {\n        return PrimitiveMethods._get(key, Primitive.Number, def);\n    }\n\n    /**\n     * Get a boolean environment variable with optional fallback.\n     * Recognizes: `1`, `yes`, `true`, `on` as **true**; `0`, `no`, `false`, `off` as **false** (case-insensitive).\n     * Accepts a single key or an ordered array of keys (first match wins).\n     */\n    static getBoolean<Default extends boolean | undefined = undefined>(\n        key: EnvKeyInput,\n        def?: Default\n    ): ConditionalReturn<boolean, Default> {\n        return this._get(key, Primitive.Boolean, def);\n    }\n\n    /**\n     * @see {@link PrimitiveMethods.getBoolean}\n     */\n    getBoolean<Default extends boolean | undefined = undefined>(\n        key: EnvKeyInput,\n        def?: Default\n    ): ConditionalReturn<boolean, Default> {\n        return PrimitiveMethods._get(key, Primitive.Boolean, def);\n    }\n\n    /**\n     * Get a bigint environment variable with optional fallback.\n     * Automatically converts string values to bigint.\n     * Accepts a single key or an ordered array of keys (first match wins).\n     */\n    static getBigInt<Default extends bigint | undefined = undefined>(\n        key: EnvKeyInput,\n        def?: Default\n    ): ConditionalReturn<bigint, Default> {\n        return this._get(key, Primitive.BigInt, def);\n    }\n\n    /**\n     * @see {@link PrimitiveMethods.getBigInt}\n     */\n    getBigInt<Default extends bigint | undefined = undefined>(\n        key: EnvKeyInput,\n        def?: Default\n    ): ConditionalReturn<bigint, Default> {\n        return PrimitiveMethods._get(key, Primitive.BigInt, def);\n    }\n\n    /**\n     * Get a symbol environment variable with optional fallback.\n     * Creates a symbol from the string value.\n     * Accepts a single key or an ordered array of keys (first match wins).\n     */\n    static getSymbol<Default extends symbol | undefined = undefined>(\n        key: EnvKeyInput,\n        def?: Default\n    ): ConditionalReturn<symbol, Default> {\n        return this._get(key, Primitive.Symbol, def);\n    }\n\n    /**\n     * @see {@link PrimitiveMethods.getSymbol}\n     */\n    getSymbol<Default extends symbol | undefined = undefined>(\n        key: EnvKeyInput,\n        def?: Default\n    ): ConditionalReturn<symbol, Default> {\n        return PrimitiveMethods._get(key, Primitive.Symbol, def);\n    }\n}\n"],"mappings":"8VAuBA,IAAa,EAAb,MAAa,UAAyB,CAA8C,CAChF,OAAwB,QAAU,IAAI,EACtC,OAA0B,iBAAqC,IAAI,EAAiB,EAAiB,OAAO,EAC5G,OAA0B,eAAiC,IAAI,EAAe,EAAiB,OAAO,EAKtG,UAAoB,CAChB,OAAO,EAAa,MACxB,CAEA,OAAe,KACX,EACA,EACA,EACgD,CAChD,GAAM,CAAE,IAAK,EAAa,SAAU,KAAK,gBAAgB,CAAG,EAC5D,GAAI,KAAK,eAAe,CAAK,EAEzB,OADI,IAAQ,IAAA,IAAW,EAAU,GAAG,EAAY,6BAA6B,OAAO,CAAG,GAAG,EACnF,EAEX,IAAM,EAAS,EAET,EAAS,KAAK,iBAAiB,gBAAgB,EAAa,OAAO,CAAM,CAAC,EAE5E,EAUJ,MATA,CAOK,EAPD,IAAA,EAAoC,EAAkB,OAAO,EAAQ,CAAa,EAC7E,IAAA,EACI,EAAkB,QAAQ,EAAQ,CAAc,EACpD,IAAA,EACI,EAAkB,OAAO,EAAQ,CAAa,EAClD,IAAA,EACI,EAAkB,OAAO,EAAQ,CAAa,EAC7C,EAAkB,OAAO,EAAQ,CAAa,EAErD,CACX,CAOA,OAAO,IACH,EACA,EACkC,CAClC,OAAO,KAAK,KAAK,EAAA,EAAuB,CAAG,CAC/C,CAKA,IACI,EACA,EACkC,CAClC,OAAO,EAAiB,KAAK,EAAA,EAAuB,CAAG,CAC3D,CAOA,OAAO,UACH,EACA,EACkC,CAClC,OAAO,KAAK,KAAK,EAAA,EAAuB,CAAG,CAC/C,CAKA,UACI,EACA,EACkC,CAClC,OAAO,EAAiB,KAAK,EAAA,EAAuB,CAAG,CAC3D,CAOA,OAAO,WACH,EACA,EACmC,CACnC,OAAO,KAAK,KAAK,EAAA,EAAwB,CAAG,CAChD,CAKA,WACI,EACA,EACmC,CACnC,OAAO,EAAiB,KAAK,EAAA,EAAwB,CAAG,CAC5D,CAOA,OAAO,UACH,EACA,EACkC,CAClC,OAAO,KAAK,KAAK,EAAA,EAAuB,CAAG,CAC/C,CAKA,UACI,EACA,EACkC,CAClC,OAAO,EAAiB,KAAK,EAAA,EAAuB,CAAG,CAC3D,CAOA,OAAO,UACH,EACA,EACkC,CAClC,OAAO,KAAK,KAAK,EAAA,EAAuB,CAAG,CAC/C,CAKA,UACI,EACA,EACkC,CAClC,OAAO,EAAiB,KAAK,EAAA,EAAuB,CAAG,CAC3D,CACJ"}

package/dist/{decorators → browser/decorators}/Envapt.d.mts

@@ -102,7 +102,7 @@ declare function Envapt<TReturnType>(key: EnvKeyInput, options: {
  *   \@Envapt(['CANARY_URL', 'APP_URL'], { converter: Converters.Url })
  *   static readonly canaryUrl: URL | null;
  *
- *   // `Converters.Time` accepts either a number (milliseconds) or a time-string fallback (`<integer><unit>`).
+ *   // `Converters.Time` accepts either a number (milliseconds) or a time-string fallback (`<number><unit>`).
  *   \@Envapt('REQUEST_TIMEOUT', { converter: Converters.Time, fallback: '10s' })
  *   static readonly requestTimeout: number;
  *

package/dist/browser/decorators/Envapt.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Envapt.d.mts","names":[],"sources":["../../../src/decorators/Envapt.ts"],"mappings":";;;;;;;;;;;AAiDA;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,MAAA,WAAA,CACZ,GAAA,EAAK,WAAA,EACL,OAAA;EACQ,SAAA,GAAY,GAAA,sBAAyB,QAAA,EAAU,SAAA,KAAc,SAAA;EAAW,QAAA,EAAU,SAAA;AAAA;EAClF,QAAA,EAAU,SAAA;EAAW,SAAA;AAAA,IAC9B,iBAAA;;;;;;;;;;;;;;;;;;;;;AA+BiB;AA+CpB;;;iBApDgB,MAAA,aAAA,CACZ,GAAA,EAAK,WAAA,EACL,OAAA;EACQ,SAAA,EAAW,iBAAA,CAAkB,WAAA;EAAc,QAAA;AAAA;EAC3C,SAAA,EAAW,iBAAA,CAAkB,WAAA;EAAc,QAAA;AAAA,IACpD,iBAAA;;;;;;;;;;;;;;;;;;;;;AAoDiB;AAoBpB;;;;;;;;;;;;;;;;;;;;;;;;iBAzBgB,MAAA,oBAA0B,gBAAA,GAAmB,OAAA,CAAA,CACzD,GAAA,EAAK,WAAA,EACL,OAAA;EACQ,SAAA,EAAW,UAAA;EAAY,QAAA,GAAW,0BAAA,CAA2B,UAAA;EAAyB,QAAA;AAAA;EACtF,SAAA,EAAW,UAAA;EAAY,QAAA;AAAA,IAChC,iBAAA;;;;;;;;AA4CqF;AAiBxF;;;;;;;;;AAAyF;iBAzCzE,MAAA,sBAA4B,oBAAA,CAAA,CACxC,GAAA,EAAK,WAAA,EACL,OAAA;EACQ,SAAA,EAAW,YAAA;EAAc,QAAA,GAAW,wBAAA,CAAyB,YAAA;EAAe,QAAA;AAAA;EAC5E,SAAA,EAAW,YAAA;EAAc,QAAA;AAAA,IAClC,iBAAA;;;;;;;;;;;;;AAkEiB;AAUpB;;;;iBAzDgB,MAAA,CAAO,GAAA,EAAK,WAAA,EAAa,OAAA;EAAW,QAAA;AAAA,IAAmB,iBAAiB;;;;;;;;;;;;;;;iBAiBxE,MAAA,8BAAA,CAAqC,GAAA,EAAK,WAAA,GAAc,iBAAiB;;;;;;;;;;;AA6CrE;;;;;;;;;;;;;;iBAnBJ,MAAA,2EAAA,CACZ,GAAA,EAAK,WAAA,EACL,QAAA,EAAU,0BAAA,CAA2B,SAAA,GACrC,SAAA,GAAY,oBAAA,GACb,iBAAA;;;;;;;;;iBAUa,MAAA,gBAAsB,gBAAA,CAAA,CAClC,GAAA,EAAK,WAAA,EACL,OAAA;EACQ,MAAA,EAAQ,gBAAA,CAAiB,MAAA;EAAS,QAAA,GAAW,iBAAA,CAAkB,MAAA;EAAS,QAAA;AAAA;EACxE,MAAA,EAAQ,gBAAA,CAAiB,MAAA;EAAS,QAAA;AAAA,IAC3C,iBAAA"}

package/dist/browser/decorators/Envapt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Envapt.mjs","names":[],"sources":["../../../src/decorators/Envapt.ts"],"sourcesContent":["import { createPropertyDecorator } from './createPropertyDecorator';\nimport { EnvaptError, EnvaptErrorCodes } from '../Error';\nimport { Validator } from '../Validators';\n\nimport type { ArrayOf } from '../converters';\nimport type { InferSchemaOutput, StandardSchemaV1 } from '../StandardSchema';\nimport type {\n    BuiltInConverter,\n    ConverterFunction,\n    EnvKeyInput,\n    EnvaptConverter,\n    EnvaptOptions,\n    InferConverterFallbackType,\n    InferPrimitiveFallbackType,\n    InferPrimitiveReturnType,\n    PrimitiveConstructor,\n    SchemaConstraint\n} from '../types';\n\n/**\n * Usage 1: Either a custom converter function + fallback (both required), OR a fallback\n * only (no converter).\n *\n * @param key - Environment variable name(s) to load\n * @param options - Configuration options\n * @public\n * @example\n * ```ts\n * class Config extends Envapter {\n *   // Custom converter that validates a non-empty API key\n *   \\@Envapt('API_KEY', {\n *     fallback: 'default-key',\n *     converter(raw, _fallback) {\n *       if (!raw || raw.trim() === '') throw new Error('API_KEY required');\n *       return raw.trim();\n *     }\n *   })\n *   static readonly apiKey: string;\n *\n *   // Fallback-only (no converter): string fallback\n *   \\@Envapt('LOG_FILE', { fallback: '/var/log/app.log' })\n *   static readonly logFile: string;\n *\n *   // Fallback-only: arbitrary object fallback\n *   \\@Envapt('RETRY_POLICY', { fallback: { retries: 3, backoff: 'exponential' } })\n *   static readonly retryPolicy: unknown;\n * }\n * ```\n */\nexport function Envapt<TFallback>(\n    key: EnvKeyInput,\n    options:\n        | { converter: (raw: string | undefined, fallback: TFallback) => TFallback; fallback: TFallback }\n        | { fallback: TFallback; converter?: undefined }\n): PropertyDecorator;\n\n/**\n * Usage 2: Custom converter function without fallback. Either omit `required` (returns the\n * converter's output, possibly `undefined`) or pass `required: true` to throw `MissingEnvValue`\n * on missing/empty values.\n *\n * @param key - Environment variable name(s) to load\n * @param options - Configuration options with custom converter only, with optional `required: true`\n * @public\n * @example\n * ```ts\n * class Config extends Envapter {\n *   \\@Envapt('FEATURE_FLAGS', { converter(raw) {\n *     return raw ? raw.split('|').map(s => s.trim()) : [];\n *   } })\n *   static readonly featureFlags: string[];\n *\n *   \\@Envapt('JWT_SECRET', {\n *     converter: (raw) => Buffer.from(raw ?? '', 'base64'),\n *     required: true\n *   })\n *   declare static readonly jwtSecret: Buffer;\n * }\n * ```\n */\nexport function Envapt<TReturnType>(\n    key: EnvKeyInput,\n    options:\n        | { converter: ConverterFunction<TReturnType>; required?: false }\n        | { converter: ConverterFunction<TReturnType>; required: true }\n): PropertyDecorator;\n\n/**\n * Usage 3: Built-in or array converter with optional fallback OR `required: true`.\n *\n * `InferConverterFallbackType` handles asymmetric cases: scalar `Converters.Time` accepts\n * `TimeFallback`, and `ArrayOf<'time'>` accepts `TimeFallback[]`. Every other converter\n * reduces to `InferConverterReturnType`. The two object-shape branches are mutually\n * exclusive: either provide a `fallback`, or pass `required: true` to throw\n * `MissingEnvValue` on missing/empty values.\n *\n * @param key - Environment variable name(s) to load\n * @param options - Configuration options\n * @public\n * @example\n * ```ts\n * import { Converters } from 'envapt';\n *\n * class Config extends Envapter {\n *   // Use built-in Number converter with a numeric fallback\n *   \\@Envapt('APP_PORT', { converter: Converters.Number, fallback: 3000 })\n *   static readonly port: number;\n *\n *   // Url converter: the fallback is a URL instance, not a string\n *   \\@Envapt('APP_URL', { converter: Converters.Url, fallback: new URL('http://localhost:3000') })\n *   static readonly url: URL;\n *\n *   // Prefer CANARY_URL when present, otherwise fall back to APP_URL\n *   \\@Envapt(['CANARY_URL', 'APP_URL'], { converter: Converters.Url })\n *   static readonly canaryUrl: URL | null;\n *\n *   // `Converters.Time` accepts either a number (milliseconds) or a time-string fallback (`<number><unit>`).\n *   \\@Envapt('REQUEST_TIMEOUT', { converter: Converters.Time, fallback: '10s' })\n *   static readonly requestTimeout: number;\n *\n *   // Array converter: comma-separated list of origins -> string[]\n *   \\@Envapt('ALLOWED_ORIGINS', {\n *     converter: Converters.array({ of: Converters.String }),\n *     fallback: ['https://example.com']\n *   })\n *   static readonly allowedOrigins: string[];\n *\n *   \\@Envapt('DATABASE_URL', { converter: Converters.Url, required: true })\n *   declare static readonly databaseUrl: URL;\n * }\n * ```\n */\nexport function Envapt<TConverter extends BuiltInConverter | ArrayOf>(\n    key: EnvKeyInput,\n    options:\n        | { converter: TConverter; fallback?: InferConverterFallbackType<TConverter> | undefined; required?: false }\n        | { converter: TConverter; required: true }\n): PropertyDecorator;\n\n/**\n * Usage 4: Primitive constructor with optional fallback\n *\n * @param key - Environment variable name(s) to load\n * @param options - Configuration options with primitive constructor\n * @public\n * @example\n * ```ts\n * // Use primitive constructors to coerce values\n * class Config extends Envapter {\n *   \\@Envapt('MAX_CONNECTIONS', { converter: Number, fallback: 100 })\n *   static readonly maxConnections: number;\n *\n *   \\@Envapt('FEATURE_ENABLED', { converter: Boolean, fallback: false })\n *   static readonly featureEnabled: boolean;\n * }\n * ```\n */\nexport function Envapt<TConstructor extends PrimitiveConstructor>(\n    key: EnvKeyInput,\n    options:\n        | { converter: TConstructor; fallback?: InferPrimitiveReturnType<TConstructor>; required?: false }\n        | { converter: TConstructor; required: true }\n): PropertyDecorator;\n\n/**\n * Usage 5: Required, no converter (raw string). Throws `MissingEnvValue` on first access if\n * the env value is missing or empty (post-trim). Independent of global `Envapter.strict`.\n * Combining `required: true` with `fallback` fails to match any overload at compile time;\n * the runtime Validator catches dynamic objects that bypass the types.\n *\n * @param key - Environment variable name(s) to load\n * @param options - `{ required: true }`\n * @public\n * @example\n * ```ts\n * class Config extends Envapter {\n *   \\@Envapt('API_KEY', { required: true })\n *   declare static readonly apiKey: string;\n * }\n * ```\n */\nexport function Envapt(key: EnvKeyInput, options: { required: true }): PropertyDecorator;\n\n/**\n * Classic API: No fallback\n *\n * @param key - Environment variable name(s) to load\n * @public\n * @example\n * ```ts\n * // Classic API: no fallback — property will resolve from env or be null\n * class Config extends Envapter {\n *   \\@Envapt('SIMPLE_VALUE')\n *   static readonly simple?: string | null;\n * }\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function Envapt<_TReturnType = string | null>(key: EnvKeyInput): PropertyDecorator;\n\n/**\n * Classic API: Primitive fallback only\n *\n * @param key - Environment variable name(s) to load\n * @param fallback - Default primitive value\n * @param converter - Optional primitive constructor (String, Number, etc.)\n * @public\n * @deprecated - Use the options object: `@Envapt('KEY', { converter, fallback })`. The positional\n * form only accepts primitive constructors and cannot express built-in tokens, array/custom\n * converters, `schema`, or `required`. Deprecated in v5, removed in v6.\n * @example\n * ```ts\n * // Classic API with primitive fallback and optional primitive converter\n * class Config extends Envapter {\n *   // Provide fallback only\n *   \\@Envapt('HOST', 'localhost')\n *   static readonly host: string;\n *\n *   // Provide fallback and converter\n *   \\@Envapt('PORT', 8080, Number)\n *   static readonly port: number;\n * }\n * ```\n */\nexport function Envapt<TFallback extends string | number | boolean | bigint | symbol | undefined>(\n    key: EnvKeyInput,\n    fallback: InferPrimitiveFallbackType<TFallback>,\n    converter?: PrimitiveConstructor\n): PropertyDecorator;\n\n/**\n * Usage 6: Standard Schema v1 adapter (zod, valibot, arktype, hand-rolled). Synchronous\n * schemas only; a Promise-returning `validate` triggers a runtime\n * `InvalidUserDefinedConfig` throw. Combining `schema` with `converter` fails to match any\n * overload at compile time; the runtime Validator catches dynamic objects that bypass the\n * types.\n * @public\n */\nexport function Envapt<Schema extends StandardSchemaV1>(\n    key: EnvKeyInput,\n    options:\n        | { schema: SchemaConstraint<Schema>; fallback?: InferSchemaOutput<Schema>; required?: false }\n        | { schema: SchemaConstraint<Schema>; required: true }\n): PropertyDecorator;\n\n/**\n * Instance/Static Property decorator that automatically loads and converts environment variables.\n */\nexport function Envapt<TFallback = unknown>(\n    key: EnvKeyInput,\n    fallbackOrOptions?: TFallback | EnvaptOptions<TFallback>,\n    converter?: EnvaptConverter<TFallback>\n): PropertyDecorator {\n    // Determine if using new options API or classic API\n    let fallback: TFallback | undefined;\n    let actualConverter: EnvaptConverter<TFallback> | undefined;\n    let actualSchema: StandardSchemaV1 | undefined;\n    let hasFallback = true;\n    let required = false;\n\n    if (\n        fallbackOrOptions &&\n        typeof fallbackOrOptions === 'object' &&\n        ('fallback' in fallbackOrOptions ||\n            'converter' in fallbackOrOptions ||\n            'required' in fallbackOrOptions ||\n            'schema' in fallbackOrOptions)\n    ) {\n        const options = fallbackOrOptions as {\n            fallback?: TFallback;\n            converter?: EnvaptConverter<TFallback>;\n            required?: boolean;\n            schema?: unknown;\n        };\n        fallback = options.fallback;\n        actualConverter = options.converter;\n        hasFallback = 'fallback' in options;\n        required = options.required === true;\n\n        if (required && hasFallback && fallback !== undefined) {\n            throw new EnvaptError(\n                EnvaptErrorCodes.InvalidUserDefinedConfig,\n                '`required: true` and `fallback` are mutually exclusive on @Envapt options. Drop the fallback or call `Envapter.require()` separately.'\n            );\n        }\n\n        if ('schema' in options && options.schema !== undefined) {\n            if (!Validator.isStandardSchema(options.schema)) {\n                throw new EnvaptError(\n                    EnvaptErrorCodes.InvalidUserDefinedConfig,\n                    '`schema` must be a Standard Schema v1 object (zod, valibot, arktype, or any `~standard`-conformant value).'\n                );\n            }\n            if (actualConverter !== undefined) {\n                throw new EnvaptError(\n                    EnvaptErrorCodes.InvalidUserDefinedConfig,\n                    '`schema` and `converter` are mutually exclusive on @Envapt options. Drop one as they both turn a raw env string into a typed value.'\n                );\n            }\n            actualSchema = options.schema;\n        }\n    } else {\n        // Classic API\n        fallback = fallbackOrOptions as TFallback;\n        actualConverter = converter;\n        hasFallback = arguments.length > 1;\n    }\n\n    return createPropertyDecorator(key, {\n        fallback,\n        converter: actualConverter,\n        hasFallback,\n        required,\n        schema: actualSchema\n    });\n}\n"],"mappings":"iKAwPA,SAAgB,EACZ,EACA,EACA,EACiB,CAEjB,IAAI,EACA,EACA,EACA,EAAc,GACd,EAAW,GAEf,GACI,GACA,OAAO,GAAsB,WAC5B,aAAc,GACX,cAAe,GACf,aAAc,GACd,WAAY,GAClB,CACE,IAAM,EAAU,EAWhB,GALA,EAAW,EAAQ,SACnB,EAAkB,EAAQ,UAC1B,EAAc,aAAc,EAC5B,EAAW,EAAQ,WAAa,GAE5B,GAAY,GAAe,IAAa,IAAA,GACxC,MAAM,IAAI,EAAA,IAEN,uIACJ,EAGJ,GAAI,WAAY,GAAW,EAAQ,SAAW,IAAA,GAAW,CACrD,GAAI,CAAC,EAAU,iBAAiB,EAAQ,MAAM,EAC1C,MAAM,IAAI,EAAA,IAEN,4GACJ,EAEJ,GAAI,IAAoB,IAAA,GACpB,MAAM,IAAI,EAAA,IAEN,qIACJ,EAEJ,EAAe,EAAQ,MAC3B,CACJ,MAEI,EAAW,EACX,EAAkB,EAClB,EAAc,UAAU,OAAS,EAGrC,OAAO,EAAwB,EAAK,CAChC,WACA,UAAW,EACX,cACA,WACA,OAAQ,CACZ,CAAC,CACL"}

package/dist/browser/decorators/SugarDecorators.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SugarDecorators.d.mts","names":[],"sources":["../../../src/decorators/SugarDecorators.ts"],"mappings":";;;;;;;AAwBA;iBAAgB,OAAA,CAAQ,GAAA,EAAK,WAAA,EAAa,QAAA,aAAqB,iBAAiB;;;;;iBAQhE,MAAA,CAAO,GAAA,EAAK,WAAA,EAAa,QAAA,YAAoB,iBAAiB;;;AARE;AAQhF;iBAQgB,MAAA,CAAO,GAAA,EAAK,WAAA,EAAa,QAAA,YAAoB,iBAAiB;;;;;;iBAS9D,OAAA,CAAQ,GAAA,EAAK,WAAA,EAAa,QAAA,GAAW,YAAA,GAAe,iBAAA;;AAjBU;AAQ9E;;;iBAkBgB,MAAA,CAAO,GAAA,EAAK,WAAA,EAAa,QAAA,GAAW,GAAA,GAAM,iBAAA"}

package/dist/browser/decorators/SugarDecorators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SugarDecorators.mjs","names":[],"sources":["../../../src/decorators/SugarDecorators.ts"],"sourcesContent":["import { createPropertyDecorator } from './createPropertyDecorator';\nimport { Converters } from '../converters';\n\nimport type { ConverterToken } from '../converters';\nimport type { EnvKeyInput, TimeFallback } from '../types';\n\nfunction sugar<TFallback>(\n    converter: ConverterToken,\n    key: EnvKeyInput,\n    fallback: TFallback | undefined\n): PropertyDecorator {\n    return createPropertyDecorator<TFallback>(key, {\n        converter,\n        fallback,\n        hasFallback: fallback !== undefined,\n        required: false,\n        schema: undefined\n    });\n}\n\n/**\n * Shorthand for `@Envapt(key, { converter: Converters.Boolean, fallback })`.\n * @public\n */\nexport function EnvBool(key: EnvKeyInput, fallback?: boolean): PropertyDecorator {\n    return sugar(Converters.Boolean, key, fallback);\n}\n\n/**\n * Shorthand for `@Envapt(key, { converter: Converters.Number, fallback })`.\n * @public\n */\nexport function EnvNum(key: EnvKeyInput, fallback?: number): PropertyDecorator {\n    return sugar(Converters.Number, key, fallback);\n}\n\n/**\n * Shorthand for `@Envapt(key, { converter: Converters.String, fallback })`.\n * @public\n */\nexport function EnvStr(key: EnvKeyInput, fallback?: string): PropertyDecorator {\n    return sugar(Converters.String, key, fallback);\n}\n\n/**\n * Shorthand for `@Envapt(key, { converter: Converters.Time, fallback })`. The fallback is a\n * millisecond number or a time string (`'15m'`); the resolved value is always milliseconds.\n * @public\n */\nexport function EnvTime(key: EnvKeyInput, fallback?: TimeFallback): PropertyDecorator {\n    return sugar(Converters.Time, key, fallback);\n}\n\n/**\n * Shorthand for `@Envapt(key, { converter: Converters.Url, fallback })`. The fallback is a `URL`\n * instance, not a URL string.\n * @public\n */\nexport function EnvUrl(key: EnvKeyInput, fallback?: URL): PropertyDecorator {\n    return sugar(Converters.Url, key, fallback);\n}\n"],"mappings":"kIAMA,SAAS,EACL,EACA,EACA,EACiB,CACjB,OAAO,EAAmC,EAAK,CAC3C,YACA,WACA,YAAa,IAAa,IAAA,GAC1B,SAAU,GACV,OAAQ,IAAA,EACZ,CAAC,CACL,CAMA,SAAgB,EAAQ,EAAkB,EAAuC,CAC7E,OAAO,EAAM,EAAW,QAAS,EAAK,CAAQ,CAClD,CAMA,SAAgB,EAAO,EAAkB,EAAsC,CAC3E,OAAO,EAAM,EAAW,OAAQ,EAAK,CAAQ,CACjD,CAMA,SAAgB,EAAO,EAAkB,EAAsC,CAC3E,OAAO,EAAM,EAAW,OAAQ,EAAK,CAAQ,CACjD,CAOA,SAAgB,EAAQ,EAAkB,EAA4C,CAClF,OAAO,EAAM,EAAW,KAAM,EAAK,CAAQ,CAC/C,CAOA,SAAgB,EAAO,EAAkB,EAAmC,CACxE,OAAO,EAAM,EAAW,IAAK,EAAK,CAAQ,CAC9C"}

package/dist/browser/decorators/createPropertyDecorator.mjs

@@ -0,0 +1,2 @@
+import{EnvaptError as e}from"../Error.mjs";import{EnvaptCache as t}from"../core/EnvapterBase.mjs";import{ValueConverter as n}from"../converters/ValueConverter.mjs";import{Envapter as r}from"../Envapter.mjs";function i(e){return Array.isArray(e)?`[${e.join(`, `)}]`:String(e)}function a(a,o){let{fallback:s,converter:c,hasFallback:l,required:u,schema:d}=o;return function(o,f){let p=String(f),m=`${typeof o==`function`?o.name:o.constructor.name}.${p}`;Object.defineProperty(o,p,{get:function(){let o=t.get(m);if(o===void 0){let f=new r;if(u&&d===void 0){let t=f.getRaw(a);if(t===void 0||t.trim()===``)throw new e(305,`Required environment variable "${i(a)}" is missing or empty.`)}let p=new n(f);o=d===void 0?p.convertValue(a,s,c,l):p.convertWithSchema(a,d,s,l),t.set(m,o)}return o},configurable:!1,enumerable:!0})}}export{a as createPropertyDecorator};
+//# sourceMappingURL=createPropertyDecorator.mjs.map

package/dist/browser/decorators/createPropertyDecorator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPropertyDecorator.mjs","names":[],"sources":["../../../src/decorators/createPropertyDecorator.ts"],"sourcesContent":["import { ValueConverter } from '../converters';\nimport { EnvaptCache } from '../core';\nimport { Envapter } from '../Envapter';\nimport { EnvaptError, EnvaptErrorCodes } from '../Error';\n\nimport type { StandardSchemaV1 } from '../StandardSchema';\nimport type { EnvaptConverter, EnvKeyInput } from '../types';\n\nfunction formatKeyForError(key: EnvKeyInput): string {\n    return Array.isArray(key) ? `[${key.join(', ')}]` : String(key);\n}\n\ninterface DecoratorConfig<TFallback> {\n    fallback: TFallback | undefined;\n    converter: EnvaptConverter<TFallback> | undefined;\n    hasFallback: boolean;\n    required: boolean;\n    schema: StandardSchemaV1 | undefined;\n}\n\nexport function createPropertyDecorator<TFallback>(\n    key: EnvKeyInput,\n    config: DecoratorConfig<TFallback>\n): PropertyDecorator {\n    const { fallback, converter, hasFallback, required, schema } = config;\n    return function (target: object, prop: string | symbol): void {\n        const propKey = String(prop);\n        // Distinguishing constructor (static) from prototype (instance) keeps same-named static and instance properties from colliding in the cache.\n        const className = typeof target === 'function' ? target.name : target.constructor.name;\n        const cacheKey = `${className}.${propKey}`;\n\n        Object.defineProperty(target, propKey, {\n            get: function () {\n                let value = EnvaptCache.get(cacheKey) as TFallback | null | undefined;\n\n                if (value === undefined) {\n                    const envapter = new Envapter();\n\n                    if (required && schema === undefined) {\n                        const rawValue = envapter.getRaw(key);\n                        if (rawValue === undefined || rawValue.trim() === '') {\n                            throw new EnvaptError(\n                                EnvaptErrorCodes.MissingEnvValue,\n                                `Required environment variable \"${formatKeyForError(key)}\" is missing or empty.`\n                            );\n                        }\n                    }\n\n                    const valueConverter = new ValueConverter(envapter);\n                    if (schema !== undefined) {\n                        value = valueConverter.convertWithSchema(key, schema, fallback, hasFallback) as TFallback;\n                    } else {\n                        value = valueConverter.convertValue(key, fallback, converter, hasFallback);\n                    }\n                    EnvaptCache.set(cacheKey, value);\n                }\n\n                return value;\n            },\n            configurable: false,\n            enumerable: true\n        });\n    };\n}\n"],"mappings":"+MAQA,SAAS,EAAkB,EAA0B,CACjD,OAAO,MAAM,QAAQ,CAAG,EAAI,IAAI,EAAI,KAAK,IAAI,EAAE,GAAK,OAAO,CAAG,CAClE,CAUA,SAAgB,EACZ,EACA,EACiB,CACjB,GAAM,CAAE,WAAU,YAAW,cAAa,WAAU,UAAW,EAC/D,OAAO,SAAU,EAAgB,EAA6B,CAC1D,IAAM,EAAU,OAAO,CAAI,EAGrB,EAAW,GADC,OAAO,GAAW,WAAa,EAAO,KAAO,EAAO,YAAY,KACpD,GAAG,IAEjC,OAAO,eAAe,EAAQ,EAAS,CACnC,IAAK,UAAY,CACb,IAAI,EAAQ,EAAY,IAAI,CAAQ,EAEpC,GAAI,IAAU,IAAA,GAAW,CACrB,IAAM,EAAW,IAAI,EAErB,GAAI,GAAY,IAAW,IAAA,GAAW,CAClC,IAAM,EAAW,EAAS,OAAO,CAAG,EACpC,GAAI,IAAa,IAAA,IAAa,EAAS,KAAK,IAAM,GAC9C,MAAM,IAAI,EAAA,IAEN,kCAAkC,EAAkB,CAAG,EAAE,uBAC7D,CAER,CAEA,IAAM,EAAiB,IAAI,EAAe,CAAQ,EAClD,AACI,EADA,IAAW,IAAA,GAGH,EAAe,aAAa,EAAK,EAAU,EAAW,CAAW,EAFjE,EAAe,kBAAkB,EAAK,EAAQ,EAAU,CAAW,EAI/E,EAAY,IAAI,EAAU,CAAK,CACnC,CAEA,OAAO,CACX,EACA,aAAc,GACd,WAAY,EAChB,CAAC,CACL,CACJ"}

package/dist/{index.d.mts → browser/index.d.mts}

@@ -1,14 +1,17 @@
+import { DebugLevel } from "./Debug.mjs";
+import { EnvFileOptions } from "./Dotenv.mjs";
 import { ArrayElement, ArrayOf, ConverterToken, Converters, CustomElementConverter, isArrayOf } from "./converters/Converters.mjs";
 import { AdvancedConverterReturn, BuiltInConverter, BuiltInConverterFunction, ConditionalReturn, ConverterFunction, EnvaptConverter, InferConverterFallbackType, InferConverterReturnType, InferPrimitiveFallbackType, InferPrimitiveReturnType, JsonValue, MapOfConverterFunctions, PrimitiveConstructor, TimeFallback, TimeUnit } from "./types/Conversion.mjs";
 import { InferSchemaInput, InferSchemaOutput, StandardSchemaV1 } from "./StandardSchema.mjs";
 import { Err, SchemaConstraint, SchemaMustBeSync } from "./types/Schema.mjs";
-import { DebugLevel } from "./Debug.mjs";
-import { EnvFileOptions } from "./Dotenv.mjs";
 import { Environment } from "./core/EnvironmentMethods.mjs";
 import { EnvProfile, EnvaptOptions, ProfilesConfig } from "./types/Options.mjs";
 import { EnvKeyInput } from "./types/Env.mjs";
+import { BareEnvSource, EnvSource, FileEnvSource } from "./types/Source.mjs";
+import { Envapter } from "./Envapter.mjs";
 import { Envapt } from "./decorators/Envapt.mjs";
 import { EnvBool, EnvNum, EnvStr, EnvTime, EnvUrl } from "./decorators/SugarDecorators.mjs";
-import { Envapter } from "./Envapter.mjs";
+import { ManualEnvSource } from "./sources/ManualEnvSource.mjs";
+import { WorkerEnvSource } from "./sources/WorkerEnvSource.mjs";
 import { EnvaptError, EnvaptErrorCodes } from "./Error.mjs";
-export { type AdvancedConverterReturn, type ArrayElement, type ArrayOf, type BuiltInConverter, type BuiltInConverterFunction, type ConditionalReturn, type ConverterFunction, type ConverterToken, Converters, type CustomElementConverter, type DebugLevel, EnvBool, type EnvFileOptions, type EnvKeyInput, EnvNum, type EnvProfile, EnvStr, EnvTime, EnvUrl, Envapt, type EnvaptConverter, EnvaptError, EnvaptErrorCodes, type EnvaptOptions, Envapter, Environment, type Err, type InferConverterFallbackType, type InferConverterReturnType, type InferPrimitiveFallbackType, type InferPrimitiveReturnType, type InferSchemaInput, type InferSchemaOutput, type JsonValue, type MapOfConverterFunctions, type PrimitiveConstructor, type ProfilesConfig, type SchemaConstraint, type SchemaMustBeSync, type StandardSchemaV1, type TimeFallback, type TimeUnit, isArrayOf };
+export { type AdvancedConverterReturn, type ArrayElement, type ArrayOf, type BareEnvSource, type BuiltInConverter, type BuiltInConverterFunction, type ConditionalReturn, type ConverterFunction, type ConverterToken, Converters, type CustomElementConverter, type DebugLevel, EnvBool, type EnvFileOptions, type EnvKeyInput, EnvNum, type EnvProfile, type EnvSource, EnvStr, EnvTime, EnvUrl, Envapt, type EnvaptConverter, EnvaptError, EnvaptErrorCodes, type EnvaptOptions, Envapter, Environment, type Err, type FileEnvSource, type InferConverterFallbackType, type InferConverterReturnType, type InferPrimitiveFallbackType, type InferPrimitiveReturnType, type InferSchemaInput, type InferSchemaOutput, type JsonValue, ManualEnvSource, type MapOfConverterFunctions, type PrimitiveConstructor, type ProfilesConfig, type SchemaConstraint, type SchemaMustBeSync, type StandardSchemaV1, type TimeFallback, type TimeUnit, WorkerEnvSource, isArrayOf };

package/dist/browser/index.mjs

@@ -0,0 +1,2 @@
+import{EnvaptError as e,EnvaptErrorCodes as t}from"./Error.mjs";import{Converters as n,isArrayOf as r}from"./converters/Converters.mjs";import{Environment as i}from"./core/EnvironmentMethods.mjs";import{Envapter as a}from"./Envapter.mjs";import{installFileApiStubs as o}from"./installFileApiStubs.mjs";import{Envapt as s}from"./decorators/Envapt.mjs";import{EnvBool as c,EnvNum as l,EnvStr as u,EnvTime as d,EnvUrl as f}from"./decorators/SugarDecorators.mjs";import{ManualEnvSource as p}from"./sources/ManualEnvSource.mjs";import{WorkerEnvSource as m}from"./sources/WorkerEnvSource.mjs";o();export{n as Converters,c as EnvBool,l as EnvNum,u as EnvStr,d as EnvTime,f as EnvUrl,s as Envapt,e as EnvaptError,t as EnvaptErrorCodes,a as Envapter,i as Environment,p as ManualEnvSource,m as WorkerEnvSource,r as isArrayOf};
+//# sourceMappingURL=index.mjs.map

package/dist/browser/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/browser.ts"],"sourcesContent":["import { Envapter } from './Envapter';\nimport { installFileApiStubs } from './installFileApiStubs';\n\nexport * from './common';\nexport { Envapter };\n\ninstallFileApiStubs();\n"],"mappings":"2kBAMA,EAAoB"}

package/dist/browser/installFileApiStubs.mjs

@@ -0,0 +1,2 @@
+import{EnvaptError as e}from"./Error.mjs";import{Envapter as t}from"./Envapter.mjs";const n=[`envPaths`,`baseDir`,`envFileOptions`,`configureProfiles`,`resetProfiles`];function r(t){throw new e(306,`Envapter.${t} requires a filesystem-backed source and is not available in this build.`)}function i(){for(let e of n)Object.defineProperty(t,e,{configurable:!0,get:()=>r(e),set:()=>r(e)})}export{i as installFileApiStubs};
+//# sourceMappingURL=installFileApiStubs.mjs.map

package/dist/browser/installFileApiStubs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"installFileApiStubs.mjs","names":[],"sources":["../../src/installFileApiStubs.ts"],"sourcesContent":["import { Envapter } from './Envapter';\nimport { EnvaptError, EnvaptErrorCodes } from './Error';\n\nconst FILE_ONLY_APIS = ['envPaths', 'baseDir', 'envFileOptions', 'configureProfiles', 'resetProfiles'] as const;\n\nfunction fileApiUnsupported(api: string): never {\n    throw new EnvaptError(\n        EnvaptErrorCodes.FileApiUnsupported,\n        `Envapter.${api} requires a filesystem-backed source and is not available in this build.`\n    );\n}\n\n// Call from each entry's own top level, not via `export * from` another entry: the build tree-shakes a\n// re-exported entry's side effect away, which would silently drop these stubs from that entry's output.\nexport function installFileApiStubs(): void {\n    for (const api of FILE_ONLY_APIS) {\n        Object.defineProperty(Envapter, api, {\n            configurable: true,\n            get: () => fileApiUnsupported(api),\n            set: () => fileApiUnsupported(api)\n        });\n    }\n}\n"],"mappings":"oFAGA,MAAM,EAAiB,CAAC,WAAY,UAAW,iBAAkB,oBAAqB,eAAe,EAErG,SAAS,EAAmB,EAAoB,CAC5C,MAAM,IAAI,EAAA,IAEN,YAAY,EAAI,yEACpB,CACJ,CAIA,SAAgB,GAA4B,CACxC,IAAK,IAAM,KAAO,EACd,OAAO,eAAe,EAAU,EAAK,CACjC,aAAc,GACd,QAAW,EAAmB,CAAG,EACjC,QAAW,EAAmB,CAAG,CACrC,CAAC,CAET"}

package/dist/browser/runtime.mjs

@@ -0,0 +1,2 @@
+let e=e=>{console.error(e)},t=()=>({});function n(t){e(t)}function r(){return t()}function i(e){t=()=>e.readVars()}export{i as bindRuntimeFromSource,r as readRuntimeEnv,n as writeRuntimeLine};
+//# sourceMappingURL=runtime.mjs.map

package/dist/browser/runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.mjs","names":[],"sources":["../../src/runtime.ts"],"sourcesContent":["import type { EnvSource } from './types';\n\n// EnvapterBase imports Debug; importing it back would cycle, so the source/sink are injected via the setters below.\n/* v8 ignore start -- @preserve replaced at load on Node; the Node suite never runs these defaults */\nlet sink: (line: string) => void = (line) => {\n    // eslint-disable-next-line no-console -- the off-Node fallback log sink\n    console.error(line);\n};\nlet envReader: () => Record<string, string> = () => ({});\n/* v8 ignore stop */\n\nexport function setRuntimeSink(fn: (line: string) => void): void {\n    sink = fn;\n}\n\nexport function writeRuntimeLine(line: string): void {\n    sink(line);\n}\n\nexport function readRuntimeEnv(): Record<string, string> {\n    return envReader();\n}\n\nexport function bindRuntimeFromSource(source: EnvSource): void {\n    envReader = (): Record<string, string> => source.readVars();\n}\n"],"mappings":"AAIA,IAAI,EAAgC,GAAS,CAEzC,QAAQ,MAAM,CAAI,CACtB,EACI,OAAiD,CAAC,GAOtD,SAAgB,EAAiB,EAAoB,CACjD,EAAK,CAAI,CACb,CAEA,SAAgB,GAAyC,CACrD,OAAO,EAAU,CACrB,CAEA,SAAgB,EAAsB,EAAyB,CAC3D,MAA0C,EAAO,SAAS,CAC9D"}

package/dist/browser/sources/ManualEnvSource.d.mts

@@ -0,0 +1,19 @@
+import { BareEnvSource } from "../types/Source.mjs";
+
+//#region src/sources/ManualEnvSource.d.ts
+/**
+ * Environment source seeded from an object you provide: the config your bundler injects into a browser
+ * build (Vite's `import.meta.env`, a webpack `DefinePlugin` global), a test fixture, or any other plain
+ * object. Pass it straight through; non-string values are JSON-stringified so the converters still apply.
+ * It has no filesystem, so the `.env` cascade and file-based APIs do not apply.
+ * @public
+ */
+declare class ManualEnvSource implements BareEnvSource {
+  readonly supportsFiles = false;
+  private readonly vars;
+  constructor(vars: Record<string, unknown>);
+  readVars(): Record<string, string>;
+}
+//#endregion
+export { ManualEnvSource };
+//# sourceMappingURL=ManualEnvSource.d.mts.map

package/dist/browser/sources/ManualEnvSource.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManualEnvSource.d.mts","names":[],"sources":["../../../src/sources/ManualEnvSource.ts"],"mappings":";;;;;AAWA;;;;;cAAa,eAAA,YAA2B,aAAA;EAAA,SAC3B,aAAA;EAAA,iBACQ,IAAA;cAEL,IAAA,EAAM,MAAA;EAIlB,QAAA,CAAA,GAAY,MAAA;AAAA"}

package/dist/browser/sources/ManualEnvSource.mjs

@@ -0,0 +1,2 @@
+import{coerceToStringRecord as e}from"./coerce.mjs";var t=class{supportsFiles=!1;vars;constructor(t){this.vars=e(t)}readVars(){return{...this.vars}}};export{t as ManualEnvSource};
+//# sourceMappingURL=ManualEnvSource.mjs.map

package/dist/browser/sources/ManualEnvSource.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManualEnvSource.mjs","names":[],"sources":["../../../src/sources/ManualEnvSource.ts"],"sourcesContent":["import { coerceToStringRecord } from './coerce';\n\nimport type { BareEnvSource } from '../types';\n\n/**\n * Environment source seeded from an object you provide: the config your bundler injects into a browser\n * build (Vite's `import.meta.env`, a webpack `DefinePlugin` global), a test fixture, or any other plain\n * object. Pass it straight through; non-string values are JSON-stringified so the converters still apply.\n * It has no filesystem, so the `.env` cascade and file-based APIs do not apply.\n * @public\n */\nexport class ManualEnvSource implements BareEnvSource {\n    readonly supportsFiles = false;\n    private readonly vars: Record<string, string>;\n\n    constructor(vars: Record<string, unknown>) {\n        this.vars = coerceToStringRecord(vars);\n    }\n\n    readVars(): Record<string, string> {\n        return { ...this.vars };\n    }\n}\n"],"mappings":"oDAWA,IAAa,EAAb,KAAsD,CAClD,cAAyB,GACzB,KAEA,YAAY,EAA+B,CACvC,KAAK,KAAO,EAAqB,CAAI,CACzC,CAEA,UAAmC,CAC/B,MAAO,CAAE,GAAG,KAAK,IAAK,CAC1B,CACJ"}

package/dist/browser/sources/UnboundEnvSource.mjs

@@ -0,0 +1,2 @@
+import{EnvaptError as e}from"../Error.mjs";var t=class{supportsFiles=!1;readVars(){throw new e(307,`No environment source is bound. Call Envapter.useSource(...) with a source such as new ManualEnvSource({...}) or new WorkerEnvSource(env) before reading.`)}};export{t as UnboundEnvSource};
+//# sourceMappingURL=UnboundEnvSource.mjs.map

package/dist/browser/sources/UnboundEnvSource.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnboundEnvSource.mjs","names":[],"sources":["../../../src/sources/UnboundEnvSource.ts"],"sourcesContent":["import { EnvaptError, EnvaptErrorCodes } from '../Error';\n\nimport type { BareEnvSource } from '../types';\n\n/**\n * The default source until one is bound. Every read throws NoSourceBound so a forgotten `useSource`\n * surfaces at read time instead of silently yielding nothing. The Node entry binds {@link NodeEnvSource}\n * at load; browser and Workers bundles must call `Envapter.useSource(...)` before reading.\n * @internal\n */\nexport class UnboundEnvSource implements BareEnvSource {\n    readonly supportsFiles = false;\n\n    readVars(): Record<string, string> {\n        throw new EnvaptError(\n            EnvaptErrorCodes.NoSourceBound,\n            'No environment source is bound. Call Envapter.useSource(...) with a source such as new ManualEnvSource({...}) or new WorkerEnvSource(env) before reading.'\n        );\n    }\n}\n"],"mappings":"2CAUA,IAAa,EAAb,KAAuD,CACnD,cAAyB,GAEzB,UAAmC,CAC/B,MAAM,IAAI,EAAA,IAEN,2JACJ,CACJ,CACJ"}

package/dist/browser/sources/WorkerEnvSource.d.mts

@@ -0,0 +1,19 @@
+import { BareEnvSource } from "../types/Source.mjs";
+
+//#region src/sources/WorkerEnvSource.d.ts
+/**
+ * Environment source for Cloudflare Workers, seeded from the `env` binding. String bindings pass
+ * through; non-string bindings are JSON-stringified so the converters still apply, and so must be
+ * JSON-serializable (a `bigint` or circular value throws). No filesystem, so the `.env` cascade and
+ * file-based APIs do not apply.
+ * @public
+ */
+declare class WorkerEnvSource implements BareEnvSource {
+  readonly supportsFiles = false;
+  private readonly vars;
+  constructor(env: Record<string, unknown>);
+  readVars(): Record<string, string>;
+}
+//#endregion
+export { WorkerEnvSource };
+//# sourceMappingURL=WorkerEnvSource.d.mts.map

package/dist/browser/sources/WorkerEnvSource.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerEnvSource.d.mts","names":[],"sources":["../../../src/sources/WorkerEnvSource.ts"],"mappings":";;;;;AAWA;;;;;cAAa,eAAA,YAA2B,aAAA;EAAA,SAC3B,aAAA;EAAA,iBACQ,IAAA;cAEL,GAAA,EAAK,MAAA;EAIjB,QAAA,CAAA,GAAY,MAAA;AAAA"}

package/dist/browser/sources/WorkerEnvSource.mjs

@@ -0,0 +1,2 @@
+import{coerceToStringRecord as e}from"./coerce.mjs";var t=class{supportsFiles=!1;vars;constructor(t){this.vars=e(t)}readVars(){return{...this.vars}}};export{t as WorkerEnvSource};
+//# sourceMappingURL=WorkerEnvSource.mjs.map

package/dist/browser/sources/WorkerEnvSource.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerEnvSource.mjs","names":[],"sources":["../../../src/sources/WorkerEnvSource.ts"],"sourcesContent":["import { coerceToStringRecord } from './coerce';\n\nimport type { BareEnvSource } from '../types';\n\n/**\n * Environment source for Cloudflare Workers, seeded from the `env` binding. String bindings pass\n * through; non-string bindings are JSON-stringified so the converters still apply, and so must be\n * JSON-serializable (a `bigint` or circular value throws). No filesystem, so the `.env` cascade and\n * file-based APIs do not apply.\n * @public\n */\nexport class WorkerEnvSource implements BareEnvSource {\n    readonly supportsFiles = false;\n    private readonly vars: Record<string, string>;\n\n    constructor(env: Record<string, unknown>) {\n        this.vars = coerceToStringRecord(env);\n    }\n\n    readVars(): Record<string, string> {\n        return { ...this.vars };\n    }\n}\n"],"mappings":"oDAWA,IAAa,EAAb,KAAsD,CAClD,cAAyB,GACzB,KAEA,YAAY,EAA8B,CACtC,KAAK,KAAO,EAAqB,CAAG,CACxC,CAEA,UAAmC,CAC/B,MAAO,CAAE,GAAG,KAAK,IAAK,CAC1B,CACJ"}

package/dist/browser/sources/coerce.mjs

@@ -0,0 +1,2 @@
+function e(e){let t={};for(let[n,r]of Object.entries(e)){if(typeof r==`string`){t[n]=r;continue}let e=JSON.stringify(r);e!==void 0&&(t[n]=e)}return t}export{e as coerceToStringRecord};
+//# sourceMappingURL=coerce.mjs.map

package/dist/browser/sources/coerce.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"coerce.mjs","names":[],"sources":["../../../src/sources/coerce.ts"],"sourcesContent":["// Shared by ManualEnvSource and WorkerEnvSource. The returned record is fresh, so a caller mutating its\n// object later can't leak into the source; non-string values are JSON-stringified.\nexport function coerceToStringRecord(env: Record<string, unknown>): Record<string, string> {\n    const snapshot: Record<string, string> = {};\n    for (const [key, value] of Object.entries(env)) {\n        if (typeof value === 'string') {\n            snapshot[key] = value;\n            continue;\n        }\n        const encoded = JSON.stringify(value);\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- TS lib mistypes JSON.stringify's return as always-string; it is string | undefined at runtime\n        if (encoded !== undefined) snapshot[key] = encoded;\n    }\n    return snapshot;\n}\n"],"mappings":"AAEA,SAAgB,EAAqB,EAAsD,CACvF,IAAM,EAAmC,CAAC,EAC1C,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,CAAG,EAAG,CAC5C,GAAI,OAAO,GAAU,SAAU,CAC3B,EAAS,GAAO,EAChB,QACJ,CACA,IAAM,EAAU,KAAK,UAAU,CAAK,EAEhC,IAAY,IAAA,KAAW,EAAS,GAAO,EAC/C,CACA,OAAO,CACX"}

package/dist/browser/types/Conversion.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Conversion.d.mts","names":[],"sources":["../../../src/types/Conversion.ts"],"mappings":";;;;;AAAgG;;;KAO3F,gBAAA,GAAmB,cAAc;AAAA;AAAA;;;AAAA,KAMjC,oBAAA,UAA8B,MAAA,UAAgB,MAAA,UAAgB,OAAA,UAAiB,MAAA,UAAgB,MAAA;;;;;KAM/F,SAAA;;;;;;;;KASA,iBAAA,yBAA0C,GAAA,EAAK,SAAA,EAAW,QAAA,GAAW,SAAA,KAAc,SAAA;AAfkB;;;;AAM5F;AAN4F,KAsBrG,eAAA,cAA6B,oBAAA,GAAuB,gBAAA,GAAmB,OAAA,GAAU,iBAAA,CAAkB,SAAA;AAAA,KAEnG,aAAA;AAAA,KACA,SAAA,GAAY,SAAS;AAAA,UAChB,UAAA;EAAA,CACL,GAAA,WAAc,SAAS;AAAA;;;;;KAOvB,SAAA,GAAY,aAAA,GAAgB,SAAA,GAAY,UAAA;AAAA,UAEnC,YAAA;EACN,MAAA;EACA,MAAA;EACA,OAAA;EACA,MAAA;EACA,MAAA;EACA,OAAA;EACA,KAAA;EACA,IAAA,EAAM,SAAA;EACN,GAAA,EAAK,GAAA;EACL,MAAA,EAAQ,MAAA;EACR,IAAA,EAAM,IAAA;EACN,IAAA;AAAA;;;;;KAOC,0BAAA,sBAAgD,gBAAA,IAAoB,YAAA,CAAa,YAAA;;;;AAjC2B;KAuC5G,gCAAA,GAAmC,YAAA,CAAa,gBAAgB;;;;AArCnD;KA2Cb,wBAAA,OACE,IAAA,EAAM,UAAA,KAAe,IAAA,YAAgB,gCAAA,MACvC,gCAAA;;;;AA5CqB;KAkDrB,uBAAA,GAA0B,MAAA,CAAO,gBAAA,EAAkB,wBAAA;;;;AAhD5B;KAsDvB,QAAA;;;;;KAMA,YAAA,wBAAoC,QAAQ;;;;;;KAO5C,iBAAA,0BAA2C,SAAA,qBAA8B,UAAA,eAAyB,UAAA;AA5DhD;AAAA;;;;;;;;AAAA,KAuElD,wBAAA,eACD,UAAA,SAAmB,OAAA,kBACb,OAAA,SAAgB,gBAAA,GACZ,YAAA,CAAa,OAAA,MACb,OAAA,SAAgB,sBAAA,mBACd,QAAA,aAEN,UAAA,SAAmB,gBAAA,GACjB,0BAAA,CAA2B,UAAA;;;;;;;KASlC,0BAAA,eAAyC,UAAA,kBACxC,YAAA,GACA,UAAA,SAAmB,OAAA,kBACjB,OAAA,kBACI,YAAA,KACA,wBAAA,CAAyB,UAAA,IAC7B,wBAAA,CAAyB,UAAA;;;;;KAM5B,uBAAA,sCAA6D,iBAAA,CAC9D,wBAAA,CAAyB,UAAA,GACzB,SAAA;;;;;KAOC,wBAAA,sBAA8C,oBAAA,IAAwB,YAAA,gBAA4B,MAAA,YAEjG,YAAA,gBAA4B,MAAA,YAE1B,YAAA,gBAA4B,OAAA,aAE1B,YAAA,gBAA4B,MAAA,YAE1B,YAAA,gBAA4B,MAAA;AAvGhC;AAAA;;;AAAA,KA+GH,0BAAA,8EACD,SAAA,2BAEM,SAAA,2BAEE,SAAA,6BAEE,SAAA,2BAEE,SAAA"}

package/dist/browser/types/Env.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Env.d.mts","names":[],"sources":["../../../src/types/Env.ts"],"mappings":";;;;;KAIK,WAAA;AAAW;AAAA;;AAAA,UAKN,eAAA;EACN,MAAA,CAAO,GAAA,EAAK,WAAA;EACZ,GAAA,CAAI,GAAA,EAAK,WAAW,EAAE,GAAA;EACtB,QAAA;AAAA"}

package/dist/{types → browser/types}/Options.d.mts

@@ -13,7 +13,7 @@ interface EnvaptOptions<TFallback = string> {
   required?: boolean;
 }
 /**
- * Per-environment profile entry passed to {@link configureProfiles}.
+ * Per-environment profile entry passed to `Envapter.configureProfiles`.
  * @public
  */
 interface EnvProfile {
@@ -21,7 +21,7 @@ interface EnvProfile {
   paths: string | string[];
 }
 /**
- * Configuration object for {@link configureProfiles}. Maps each `Environment` to an optional
+ * Configuration object for `Envapter.configureProfiles`. Maps each `Environment` to an optional
  * profile override. Unspecified environments fall through to the default cascade behavior
  * (`.env.${env}.local`, `.env.local`, `.env.${env}`, `.env`).
  * @public

package/dist/browser/types/Options.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Options.d.mts","names":[],"sources":["../../../src/types/Options.ts"],"mappings":";;;;;;AAC8D;;;UAOpD,aAAA;EACN,QAAA,GAAW,SAAA;EACX,SAAA,GAAY,eAAA,CAAgB,SAAA;EAC5B,QAAA;AAAA;;;;;UAOM,UAAA;EARsB;EAU5B,KAAK;AAAA;AATG;AAAA;;;;AASH;AATG,KAkBP,cAAA,GAAiB,OAAA,CAAQ,MAAA,CAAO,WAAA,EAAa,UAAA;EAA/B;;;;;EAMf,WAAA;AAAA"}

package/dist/browser/types/Schema.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.d.mts","names":[],"sources":["../../../src/types/Schema.ts"],"mappings":";;;cAKc,eAAA;AAAA,KACT,GAAA,uBAA0B,GAAA;EAAA,UAAkB,eAAe;AAAA;AAAA,KAE3D,gBAAA,GACD,GAAG;AAAA,KAIF,gBAAA,gBAAgC,gBAAA,IACjC,UAAA,CAAW,MAAA,mCAAyC,OAAA,YAAmB,gBAAA,GAAmB,MAAA"}

package/dist/browser/types/Source.d.mts

@@ -0,0 +1,44 @@
+//#region src/types/Source.d.ts
+/**
+ * A source with no filesystem: an injected object on the browser, or the Cloudflare `env` binding on
+ * Workers. The `.env` cascade, profiles, and the `envPaths`/`baseDir`/`configureProfiles` APIs do not
+ * apply; only `readVars()` populates the cache.
+ * @public
+ */
+interface BareEnvSource {
+  /** Return every variable this source provides, as plain strings. */
+  readVars(): Record<string, string>;
+  /** Leave unset (or `false`); a bare source has no filesystem. */
+  readonly supportsFiles?: false;
+}
+/**
+ * A filesystem-backed source, like the default {@link NodeEnvSource}. Setting `supportsFiles` to
+ * `true` requires all four file capabilities, so the engine can load the `.env` cascade, resolve
+ * `baseDir`, and mirror loaded keys back to the ambient environment.
+ * @public
+ */
+interface FileEnvSource {
+  /** Return every variable this source provides, as plain strings. */
+  readVars(): Record<string, string>;
+  /** When `true`, the engine loads the `.env` cascade, profiles, and `envPaths` through the methods below. */
+  readonly supportsFiles: true;
+  /** Read a file's text, or `undefined` when it is absent or unreadable. Backs the loader and existence checks. */
+  readFile(path: string, encoding: string): string | undefined;
+  /** Join a relative `.env` path onto `baseDir`; absolute paths are returned unchanged. */
+  resolvePath(baseDir: string, candidate: string): string;
+  /** Normalize a `baseDir` value (a directory path, or a module / `file:` URL) to an absolute directory path. */
+  normalizeBaseDir(value: string | URL): string;
+  /** Mirror loaded keys back to the ambient environment (e.g. `process.env`); backs `Envapter.syncProcessEnv`. */
+  writeVars(vars: Record<string, string>): void;
+}
+/**
+ * A pluggable source of environment variables. The default {@link NodeEnvSource} (a
+ * {@link FileEnvSource}) reads `process.env` plus the `.env` cascade; a {@link BareEnvSource} lets the
+ * same engine run where there is no ambient environment (an injected object on the browser, the
+ * Cloudflare `env` binding on Workers). Bind one with `Envapter.useSource`.
+ * @public
+ */
+type EnvSource = BareEnvSource | FileEnvSource;
+//#endregion
+export type { BareEnvSource, EnvSource, FileEnvSource };
+//# sourceMappingURL=Source.d.mts.map

package/dist/browser/types/Source.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Source.d.mts","names":[],"sources":["../../../src/types/Source.ts"],"mappings":";;;;;;;UAMU,aAAA;EAIG;EAFT,QAAA,IAAY,MAAM;EAEI;EAAA,SAAb,aAAA;AAAA;;;;;;;UASH,aAAA;EAEM;EAAZ,QAAA,IAAY,MAAA;EAIZ;EAAA,SAFS,aAAA;EAEc;EAAvB,QAAA,CAAS,IAAA,UAAc,QAAA;EAEX;EAAZ,WAAA,CAAY,OAAA,UAAiB,SAAA;EAE7B;EAAA,gBAAA,CAAiB,KAAA,WAAgB,GAAA;EAAhB;EAEjB,SAAA,CAAU,IAAA,EAAM,MAAA;AAAA;;;AAAsB;AAAA;;;;KAUrC,SAAA,GAAY,aAAA,GAAgB,aAAa"}

package/dist/node/Debug.cjs

@@ -0,0 +1,2 @@
+const e=require("./Error.cjs"),t=require("./runtime.cjs"),n=new Set([`silent`,`warn`,`verbose`]);let r=`silent`,i=!1;function a(e){return e!==void 0&&n.has(e)}function o(){if(!i){let e=t.readRuntimeEnv().ENVAPT_DEBUG;r=a(e)?e:`silent`,i=!0}return r}function s(t){if(!a(t))throw new e.EnvaptError(302,`Invalid debug level "${String(t)}". Expected 'silent' | 'warn' | 'verbose'.`);r=t,i=!0}function c(){return o()}function l(e){let n=o();(n===`warn`||n===`verbose`)&&t.writeRuntimeLine(`[envapt] ${e}`)}function u(e){o()===`verbose`&&t.writeRuntimeLine(`[envapt] ${e}`)}exports.debugVerbose=u,exports.debugWarn=l,exports.getDebugLevel=c,exports.setDebugLevel=s;
+//# sourceMappingURL=Debug.cjs.map

package/dist/node/Debug.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Debug.cjs","names":["readRuntimeEnv","EnvaptError"],"sources":["../../src/Debug.ts"],"sourcesContent":["import { EnvaptError, EnvaptErrorCodes } from './Error';\nimport { readRuntimeEnv, writeRuntimeLine } from './runtime';\n\n/**\n * Debug log levels for {@link Envapter.debug}. `silent` (default) emits nothing.\n * `warn` covers signals that might indicate misconfiguration: failed file reads,\n * unresolved templates (when not strict), fallback values used in place of missing\n * env. `verbose` adds every loaded file, per-file key count, per-key load lines, and\n * effective-paths / cache-rebuild notices.\n * @public\n */\nexport type DebugLevel = 'silent' | 'warn' | 'verbose';\n\nconst VALID_LEVELS: ReadonlySet<string> = new Set<DebugLevel>(['silent', 'warn', 'verbose']);\n\nlet currentLevel: DebugLevel = 'silent';\nlet initialized = false;\n\nfunction isDebugLevel(value: string | undefined): value is DebugLevel {\n    return value !== undefined && VALID_LEVELS.has(value);\n}\n\n// Reads `ENVAPT_DEBUG` lazily on first access. Setter wins after that.\nfunction resolveLevel(): DebugLevel {\n    if (!initialized) {\n        const fromEnv = readRuntimeEnv().ENVAPT_DEBUG;\n        currentLevel = isDebugLevel(fromEnv) ? fromEnv : 'silent';\n        initialized = true;\n    }\n    return currentLevel;\n}\n\n/** @internal */\nexport function setDebugLevel(level: DebugLevel): void {\n    if (!isDebugLevel(level)) {\n        throw new EnvaptError(\n            EnvaptErrorCodes.InvalidUserDefinedConfig,\n            `Invalid debug level \"${String(level)}\". Expected 'silent' | 'warn' | 'verbose'.`\n        );\n    }\n    currentLevel = level;\n    initialized = true;\n}\n\n/** @internal */\nexport function getDebugLevel(): DebugLevel {\n    return resolveLevel();\n}\n\n/** @internal */\nexport function resetDebugForTesting(): void {\n    currentLevel = 'silent';\n    initialized = false;\n}\n\n/** @internal */\nexport function debugWarn(message: string): void {\n    const level = resolveLevel();\n    if (level === 'warn' || level === 'verbose') {\n        writeRuntimeLine(`[envapt] ${message}`);\n    }\n}\n\n/** @internal */\nexport function debugVerbose(message: string): void {\n    if (resolveLevel() === 'verbose') {\n        writeRuntimeLine(`[envapt] ${message}`);\n    }\n}\n"],"mappings":"0DAaM,EAAoC,IAAI,IAAgB,CAAC,SAAU,OAAQ,SAAS,CAAC,EAE3F,IAAI,EAA2B,SAC3B,EAAc,GAElB,SAAS,EAAa,EAAgD,CAClE,OAAO,IAAU,IAAA,IAAa,EAAa,IAAI,CAAK,CACxD,CAGA,SAAS,GAA2B,CAChC,GAAI,CAAC,EAAa,CACd,IAAM,EAAUA,EAAAA,eAAe,EAAE,aACjC,EAAe,EAAa,CAAO,EAAI,EAAU,SACjD,EAAc,EAClB,CACA,OAAO,CACX,CAGA,SAAgB,EAAc,EAAyB,CACnD,GAAI,CAAC,EAAa,CAAK,EACnB,MAAM,IAAIC,EAAAA,YAAAA,IAEN,wBAAwB,OAAO,CAAK,EAAE,2CAC1C,EAEJ,EAAe,EACf,EAAc,EAClB,CAGA,SAAgB,GAA4B,CACxC,OAAO,EAAa,CACxB,CASA,SAAgB,EAAU,EAAuB,CAC7C,IAAM,EAAQ,EAAa,GACvB,IAAU,QAAU,IAAU,YAC9B,EAAA,iBAAiB,YAAY,GAAS,CAE9C,CAGA,SAAgB,EAAa,EAAuB,CAC5C,EAAa,IAAM,WACnB,EAAA,iBAAiB,YAAY,GAAS,CAE9C"}

package/dist/node/Debug.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Debug.d.cts","names":[],"sources":["../../src/Debug.ts"],"mappings":";;AAWA;;;;AAAsB;;;KAAV,UAAA"}

package/dist/node/Debug.d.mts

@@ -0,0 +1,13 @@
+//#region src/Debug.d.ts
+/**
+ * Debug log levels for {@link Envapter.debug}. `silent` (default) emits nothing.
+ * `warn` covers signals that might indicate misconfiguration: failed file reads,
+ * unresolved templates (when not strict), fallback values used in place of missing
+ * env. `verbose` adds every loaded file, per-file key count, per-key load lines, and
+ * effective-paths / cache-rebuild notices.
+ * @public
+ */
+type DebugLevel = 'silent' | 'warn' | 'verbose';
+//#endregion
+export { DebugLevel };
+//# sourceMappingURL=Debug.d.mts.map

package/dist/node/Debug.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Debug.d.mts","names":[],"sources":["../../src/Debug.ts"],"mappings":";;AAWA;;;;AAAsB;;;KAAV,UAAA"}

package/dist/node/Debug.mjs

@@ -0,0 +1,2 @@
+import{EnvaptError as e}from"./Error.mjs";import{readRuntimeEnv as t,writeRuntimeLine as n}from"./runtime.mjs";const r=new Set([`silent`,`warn`,`verbose`]);let i=`silent`,a=!1;function o(e){return e!==void 0&&r.has(e)}function s(){if(!a){let e=t().ENVAPT_DEBUG;i=o(e)?e:`silent`,a=!0}return i}function c(t){if(!o(t))throw new e(302,`Invalid debug level "${String(t)}". Expected 'silent' | 'warn' | 'verbose'.`);i=t,a=!0}function l(){return s()}function u(e){let t=s();(t===`warn`||t===`verbose`)&&n(`[envapt] ${e}`)}function d(e){s()===`verbose`&&n(`[envapt] ${e}`)}export{d as debugVerbose,u as debugWarn,l as getDebugLevel,c as setDebugLevel};
+//# sourceMappingURL=Debug.mjs.map

package/dist/node/Debug.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Debug.mjs","names":[],"sources":["../../src/Debug.ts"],"sourcesContent":["import { EnvaptError, EnvaptErrorCodes } from './Error';\nimport { readRuntimeEnv, writeRuntimeLine } from './runtime';\n\n/**\n * Debug log levels for {@link Envapter.debug}. `silent` (default) emits nothing.\n * `warn` covers signals that might indicate misconfiguration: failed file reads,\n * unresolved templates (when not strict), fallback values used in place of missing\n * env. `verbose` adds every loaded file, per-file key count, per-key load lines, and\n * effective-paths / cache-rebuild notices.\n * @public\n */\nexport type DebugLevel = 'silent' | 'warn' | 'verbose';\n\nconst VALID_LEVELS: ReadonlySet<string> = new Set<DebugLevel>(['silent', 'warn', 'verbose']);\n\nlet currentLevel: DebugLevel = 'silent';\nlet initialized = false;\n\nfunction isDebugLevel(value: string | undefined): value is DebugLevel {\n    return value !== undefined && VALID_LEVELS.has(value);\n}\n\n// Reads `ENVAPT_DEBUG` lazily on first access. Setter wins after that.\nfunction resolveLevel(): DebugLevel {\n    if (!initialized) {\n        const fromEnv = readRuntimeEnv().ENVAPT_DEBUG;\n        currentLevel = isDebugLevel(fromEnv) ? fromEnv : 'silent';\n        initialized = true;\n    }\n    return currentLevel;\n}\n\n/** @internal */\nexport function setDebugLevel(level: DebugLevel): void {\n    if (!isDebugLevel(level)) {\n        throw new EnvaptError(\n            EnvaptErrorCodes.InvalidUserDefinedConfig,\n            `Invalid debug level \"${String(level)}\". Expected 'silent' | 'warn' | 'verbose'.`\n        );\n    }\n    currentLevel = level;\n    initialized = true;\n}\n\n/** @internal */\nexport function getDebugLevel(): DebugLevel {\n    return resolveLevel();\n}\n\n/** @internal */\nexport function resetDebugForTesting(): void {\n    currentLevel = 'silent';\n    initialized = false;\n}\n\n/** @internal */\nexport function debugWarn(message: string): void {\n    const level = resolveLevel();\n    if (level === 'warn' || level === 'verbose') {\n        writeRuntimeLine(`[envapt] ${message}`);\n    }\n}\n\n/** @internal */\nexport function debugVerbose(message: string): void {\n    if (resolveLevel() === 'verbose') {\n        writeRuntimeLine(`[envapt] ${message}`);\n    }\n}\n"],"mappings":"+GAaA,MAAM,EAAoC,IAAI,IAAgB,CAAC,SAAU,OAAQ,SAAS,CAAC,EAE3F,IAAI,EAA2B,SAC3B,EAAc,GAElB,SAAS,EAAa,EAAgD,CAClE,OAAO,IAAU,IAAA,IAAa,EAAa,IAAI,CAAK,CACxD,CAGA,SAAS,GAA2B,CAChC,GAAI,CAAC,EAAa,CACd,IAAM,EAAU,EAAe,EAAE,aACjC,EAAe,EAAa,CAAO,EAAI,EAAU,SACjD,EAAc,EAClB,CACA,OAAO,CACX,CAGA,SAAgB,EAAc,EAAyB,CACnD,GAAI,CAAC,EAAa,CAAK,EACnB,MAAM,IAAI,EAAA,IAEN,wBAAwB,OAAO,CAAK,EAAE,2CAC1C,EAEJ,EAAe,EACf,EAAc,EAClB,CAGA,SAAgB,GAA4B,CACxC,OAAO,EAAa,CACxB,CASA,SAAgB,EAAU,EAAuB,CAC7C,IAAM,EAAQ,EAAa,GACvB,IAAU,QAAU,IAAU,YAC9B,EAAiB,YAAY,GAAS,CAE9C,CAGA,SAAgB,EAAa,EAAuB,CAC5C,EAAa,IAAM,WACnB,EAAiB,YAAY,GAAS,CAE9C"}

package/dist/node/Dotenv.cjs

@@ -0,0 +1,3 @@
+const e=require("./Debug.cjs"),t=/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=(.*)$/u;function n(e){let t=new Map,n=e.split(/\r?\n/u);for(let e=0;e<n.length;e++){let i=r(n,e);e=i.endLine,i.entry&&t.set(i.entry.key,i.entry.value)}return t}function r(e,n){let r=e[n]??``,o=r.trim();if(o===``||o.startsWith(`#`))return{entry:void 0,endLine:n};let s=r.match(t);if(!s)return{entry:void 0,endLine:n};let c=s[1],l=(s[2]??``).replace(/^\s+/u,``),u=l[0];if(u===`"`||u===`'`||u==="`"){let t=i(l,e,n,u);return{entry:{key:c,value:t.value},endLine:t.endLine}}return{entry:{key:c,value:a(l)},endLine:n}}function i(e,t,n,r){let i=e,a=n,o=s(i,r);for(;o<0&&a<t.length-1;)a++,i+=`\n${t[a]??``}`,o=s(i,r);let l=o>0?i.slice(1,o):i.slice(1);return{value:r===`"`?c(l):l,endLine:a}}function a(e){let t=o(e);return(t===-1?e:e.slice(0,t)).trimEnd()}function o(e){for(let t=0;t<e.length;t++)if(e[t]===`#`&&(t===0||/\s/u.test(e[t-1])))return t;return-1}function s(e,t){for(let n=e.length-1;n>0;n--)if(e[n]===t){if(t===`"`){let t=0,r=n-1;for(;r>=0&&e[r]===`\\`;)t++,r--;if(t%2==1)continue}return n}return-1}function c(e){let t=``;for(let n=0;n<e.length;n++){let r=e[n];if(r!==`\\`||n===e.length-1){t+=r;continue}let i=e[n+1];switch(n++,i){case`n`:t+=`
+`;break;case`r`:t+=`\r`;break;case`t`:t+=`	`;break;case`\\`:t+=`\\`;break;case`"`:t+=`"`;break;default:t+=`\\${i??``}`}}return t}function l(t){let r=Array.isArray(t.path)?t.path:[t.path],i=t.encoding??`utf8`,a=t.override??!1,o=new Set;for(let s of r){let r=t.readFile(s,i);if(r===void 0){e.debugWarn(`could not read ${s}`);continue}let c=n(r);e.debugVerbose(`loaded ${s}: ${c.size} ${c.size===1?`key`:`keys`}`);for(let[n,r]of c)(!Object.prototype.hasOwnProperty.call(t.processEnv,n)||a)&&(t.processEnv[n]=r,o.add(n),e.debugVerbose(`${s} -> ${n}`))}return o}exports.loadDotenv=l;
+//# sourceMappingURL=Dotenv.cjs.map