envapt 5.1.0 → 5.2.0-next.0

package/dist/node/types/Options.d.mts

@@ -0,0 +1,39 @@
+import { EnvaptConverter } from "./Conversion.mjs";
+import { Environment } from "../core/EnvironmentMethods.mjs";
+
+//#region src/types/Options.d.ts
+/**
+ * Options for the \@Envapt decorator (modern API). `required: true` is mutually exclusive
+ * with `fallback`; see the per-converter overloads in `Envapt.ts` for the type-level mutex.
+ * @public
+ */
+interface EnvaptOptions<TFallback = string> {
+  fallback?: TFallback;
+  converter?: EnvaptConverter<TFallback>;
+  required?: boolean;
+}
+/**
+ * Per-environment profile entry passed to `Envapter.configureProfiles`.
+ * @public
+ */
+interface EnvProfile {
+  /** One or more `.env` paths to load for this environment. Order matters: earlier paths take precedence. */
+  paths: string | string[];
+}
+/**
+ * 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
+ */
+type ProfilesConfig = Partial<Record<Environment, EnvProfile>> & {
+  /**
+   * When `false`, disables the default dotenv-flow cascade entirely. Only the explicitly
+   * configured paths are loaded. Defaults to `true` (cascade still runs, configured paths
+   * are layered on top with higher precedence).
+   */
+  useDefaults?: boolean;
+};
+//#endregion
+export type { EnvProfile, EnvaptOptions, ProfilesConfig };
+//# sourceMappingURL=Options.d.mts.map

package/dist/node/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/node/types/Schema.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.d.cts","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/node/types/Schema.d.mts

@@ -0,0 +1,12 @@
+import { StandardSchemaV1 } from "../StandardSchema.mjs";
+
+//#region src/types/Schema.d.ts
+declare const _envaptErrBrand: unique symbol;
+type Err<Msg extends string> = Msg & {
+  readonly [_envaptErrBrand]: never;
+};
+type SchemaMustBeSync = Err<'Schema must be synchronous. envapt is boot-time config loading; async refinements (validate returning `Promise<Result>`) belong outside the env layer.'>;
+type SchemaConstraint<Schema extends StandardSchemaV1> = ReturnType<Schema['~standard']['validate']> extends Promise<unknown> ? SchemaMustBeSync : Schema;
+//#endregion
+export type { Err, SchemaConstraint, SchemaMustBeSync };
+//# sourceMappingURL=Schema.d.mts.map

package/dist/node/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/node/types/Source.d.cts

@@ -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.cts.map

package/dist/node/types/Source.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Source.d.cts","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/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/node/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/workerd/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/workerd/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/workerd/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/workerd/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/workerd/Dotenv.d.mts

@@ -0,0 +1,17 @@
+//#region src/Dotenv.d.ts
+/**
+ * Public options for the internal `.env` loader. Mirrors the subset of dotenv's
+ * `config()` options that envapt actually supports (no DOTENV_KEY, no quiet).
+ * For debug output, use `Envapter.debug` (or the `ENVAPT_DEBUG` env var).
+ *
+ * @public
+ */
+interface EnvFileOptions {
+  /** Encoding for reading .env files. Defaults to 'utf8'. */
+  encoding?: string;
+  /** When true, later files override earlier ones (and existing processEnv values). Default false (first-wins). */
+  override?: boolean;
+}
+//#endregion
+export { EnvFileOptions };
+//# sourceMappingURL=Dotenv.d.mts.map

package/dist/workerd/Dotenv.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dotenv.d.mts","names":[],"sources":["../../src/Dotenv.ts"],"mappings":";;AASA;;;;AAIY;;UAJK,cAAA;;EAEb,QAAA;;EAEA,QAAQ;AAAA"}

package/dist/workerd/Dotenv.mjs

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

package/dist/workerd/Dotenv.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dotenv.mjs","names":[],"sources":["../../src/Dotenv.ts"],"sourcesContent":["import { debugVerbose, debugWarn } from './Debug';\n\n/**\n * Public options for the internal `.env` loader. Mirrors the subset of dotenv's\n * `config()` options that envapt actually supports (no DOTENV_KEY, no quiet).\n * For debug output, use `Envapter.debug` (or the `ENVAPT_DEBUG` env var).\n *\n * @public\n */\nexport interface EnvFileOptions {\n    /** Encoding for reading .env files. Defaults to 'utf8'. */\n    encoding?: string;\n    /** When true, later files override earlier ones (and existing processEnv values). Default false (first-wins). */\n    override?: boolean;\n}\n\n/**\n * Internal call signature used by `EnvapterBase`. The `path` and `processEnv`\n * fields are managed by envapt and never user-supplied.\n * @internal\n */\nexport interface LoadDotenvInput extends EnvFileOptions {\n    path: string | string[];\n    processEnv: Record<string, string>;\n    // Injected so the loader stays free of `node:fs`. Returns `undefined` when the file is absent.\n    readFile(path: string, encoding: string): string | undefined;\n}\n\n// Matches: optional `export`, KEY name, optional whitespace, `=`, optional whitespace, value tail.\n// Multi-line quoted values are handled by re-buffering subsequent lines below.\n// Bounded by anchors with linear-time quantifiers; no catastrophic backtracking risk -- justified\n// eslint-disable-next-line security/detect-unsafe-regex\nconst KEY_LINE_RE = /^\\s*(?:export\\s+)?([A-Za-z_][A-Za-z0-9_]*)\\s*=(.*)$/u;\n\n/**\n * Parse a `.env` text blob into a `Map<string, string>`.\n *\n * Supported syntax:\n * - `KEY=value` and `export KEY=value`\n * - blank lines and full-line `# comments`\n * - single-quoted `'literal'` values (no escape interpretation)\n * - double-quoted `\"value\"` values (interprets `\\n`, `\\r`, `\\t`, `\\\\`, `\\\"`)\n * - backtick-quoted values (literal, like single quotes)\n * - quoted values may span multiple lines\n * - inline `# comment` after an unquoted value (requires whitespace before `#`)\n * - empty values resolve to `\"\"`\n *\n * Mirrors dotenv's quirk where unescaped inner quotes inside a quoted value\n * are tolerated by greedy-matching to the rightmost matching quote on the\n * (possibly multi-line) value buffer. This is what lets a value like\n * `JSON=\"{\"name\":\"x\"}\"` round-trip without escaping.\n *\n * Does NOT perform `${VAR}` expansion — envapt's `Parser` handles that downstream.\n * @internal\n */\nexport function parseDotenv(src: string): Map<string, string> {\n    const out = new Map<string, string>();\n    const lines = src.split(/\\r?\\n/u);\n\n    for (let i = 0; i < lines.length; i++) {\n        const consumed = parseEntry(lines, i);\n        i = consumed.endLine;\n        if (consumed.entry) out.set(consumed.entry.key, consumed.entry.value);\n    }\n\n    return out;\n}\n\ninterface ParsedEntry {\n    key: string;\n    value: string;\n}\n\nfunction parseEntry(lines: string[], start: number): { entry: ParsedEntry | undefined; endLine: number } {\n    /* v8 ignore next -- @preserve caller bounds-checks start so this never falls back */\n    const line = lines[start] ?? '';\n    const trimmedLine = line.trim();\n    if (trimmedLine === '' || trimmedLine.startsWith('#')) return { entry: undefined, endLine: start };\n\n    const match = line.match(KEY_LINE_RE);\n    if (!match) return { entry: undefined, endLine: start };\n\n    const key = match[1] as string;\n    // Drop only leading whitespace before the value; trailing whitespace and inline comments\n    // are dealt with below depending on whether the value is quoted.\n    /* v8 ignore next -- @preserve regex group 2 always matches via `(.*)`, fallback is defensive */\n    const rest = (match[2] ?? '').replace(/^\\s+/u, '');\n    const firstChar = rest[0];\n\n    if (firstChar === '\"' || firstChar === \"'\" || firstChar === '`') {\n        const consumed = consumeQuotedValue(rest, lines, start, firstChar);\n        return { entry: { key, value: consumed.value }, endLine: consumed.endLine };\n    }\n\n    return { entry: { key, value: stripInlineComment(rest) }, endLine: start };\n}\n\nfunction consumeQuotedValue(\n    firstLineRest: string,\n    lines: string[],\n    startLine: number,\n    quote: string\n): { value: string; endLine: number } {\n    let buffer = firstLineRest;\n    let cursor = startLine;\n    let closeIdx = findLastUnescapedQuote(buffer, quote);\n\n    while (closeIdx < 0 && cursor < lines.length - 1) {\n        cursor++;\n        /* v8 ignore next -- @preserve cursor is bounded by the while condition above */\n        buffer += `\\n${lines[cursor] ?? ''}`;\n        closeIdx = findLastUnescapedQuote(buffer, quote);\n    }\n\n    const inner = closeIdx > 0 ? buffer.slice(1, closeIdx) : buffer.slice(1);\n    return { value: quote === '\"' ? unescapeDouble(inner) : inner, endLine: cursor };\n}\n\nfunction stripInlineComment(value: string): string {\n    const hashIdx = findInlineCommentStart(value);\n    const stripped = hashIdx === -1 ? value : value.slice(0, hashIdx);\n    return stripped.trimEnd();\n}\n\nfunction findInlineCommentStart(value: string): number {\n    for (let i = 0; i < value.length; i++) {\n        if (value[i] === '#' && (i === 0 || /\\s/u.test(value[i - 1] as string))) return i;\n    }\n    return -1;\n}\n\n/**\n * Find the rightmost matching closing quote in `buffer` (skipping index 0 which is the\n * opening quote). For `\"`, a quote preceded by an odd number of backslashes is escaped\n * and ignored. Single and backtick quotes do not unescape.\n */\nfunction findLastUnescapedQuote(buffer: string, quote: string): number {\n    for (let i = buffer.length - 1; i > 0; i--) {\n        if (buffer[i] !== quote) continue;\n        if (quote === '\"') {\n            let backslashes = 0;\n            let k = i - 1;\n            while (k >= 0 && buffer[k] === '\\\\') {\n                backslashes++;\n                k--;\n            }\n            if (backslashes % 2 === 1) continue; // escaped\n        }\n        return i;\n    }\n    return -1;\n}\n\nfunction unescapeDouble(raw: string): string {\n    let out = '';\n    for (let i = 0; i < raw.length; i++) {\n        const ch = raw[i];\n        if (ch !== '\\\\' || i === raw.length - 1) {\n            out += ch;\n            continue;\n        }\n        const next = raw[i + 1];\n        i++;\n        switch (next) {\n            case 'n':\n                out += '\\n';\n                break;\n            case 'r':\n                out += '\\r';\n                break;\n            case 't':\n                out += '\\t';\n                break;\n            case '\\\\':\n                out += '\\\\';\n                break;\n            case '\"':\n                out += '\"';\n                break;\n            default:\n                /* v8 ignore next -- @preserve `next` is always defined when this branch is reached (guarded above) */\n                out += `\\\\${next ?? ''}`;\n        }\n    }\n    return out;\n}\n\n/**\n * Load one or more `.env` files into a target `processEnv` map. Mirrors the\n * subset of dotenv's `config()` semantics that envapt depends on: first-wins\n * across multiple paths by default, optional `override: true`, optional\n * non-UTF8 encoding, missing files are skipped silently.\n *\n * Returns the set of keys actually written into `input.processEnv`. Skipped\n * collisions (under default `override: false`) are NOT included.\n * @internal\n */\nexport function loadDotenv(input: LoadDotenvInput): Set<string> {\n    const paths = Array.isArray(input.path) ? input.path : [input.path];\n    const encoding = input.encoding ?? 'utf8';\n    const override = input.override ?? false;\n    const written = new Set<string>();\n\n    for (const filePath of paths) {\n        const src = input.readFile(filePath, encoding);\n        if (src === undefined) {\n            debugWarn(`could not read ${filePath}`);\n            continue;\n        }\n\n        const parsed = parseDotenv(src);\n        debugVerbose(`loaded ${filePath}: ${parsed.size} ${parsed.size === 1 ? 'key' : 'keys'}`);\n        for (const [key, value] of parsed) {\n            const exists = Object.prototype.hasOwnProperty.call(input.processEnv, key);\n            if (!exists || override) {\n                input.processEnv[key] = value;\n                written.add(key);\n                debugVerbose(`${filePath} -> ${key}`);\n            }\n        }\n    }\n\n    return written;\n}\n"],"mappings":"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"}

package/dist/workerd/Envapter.d.mts

@@ -0,0 +1,70 @@
+import { Environment } from "./core/EnvironmentMethods.mjs";
+import { AdvancedMethods } from "./core/AdvancedMethods.mjs";
+
+//#region src/Envapter.d.ts
+/**
+ * Main configuration class for environment variable management.
+ *
+ * Provides both static and instance methods for retrieving typed environment variables
+ * with support for template resolution, multiple .env files, and environment detection.
+ *
+ * Extend your own classes from this to define properties with \@Envapt decorators and get access to environment-variable methods.
+ *
+ * @example
+ * ```ts
+ * // Static usage
+ * const port = Envapter.getNumber('PORT', 3000);
+ * const url = Envapter.get('API_URL', 'http://localhost');
+ * const replica = Envapter.get(['READONLY_URL', 'DATABASE_URL'], 'sqlite://memory');
+ *
+ * // Instance usage
+ * const env = new Envapter();
+ * const dbUrl = env.get('DATABASE_URL', 'sqlite://memory');
+ * const primaryHost = env.get(['PRIMARY_HOST', 'SECONDARY_HOST']);
+ * ```
+ *
+ * @public
+ */
+declare class Envapter extends AdvancedMethods {
+  /**
+   * Tagged template literal for resolving environment variables in template strings.
+   *
+   * @example
+   * ```ts
+   * // Given API_HOST=api.example.com and API_PORT=8080 in environment
+   * const endpoint = Envapter.resolve`Connecting to ${'API_HOST'}:${'API_PORT'}`;
+   * // Returns: "Connecting to api.example.com:8080"
+   *
+   * // Works with template variables in .env too:
+   * // API_URL=https://${API_HOST}:${API_PORT}
+   * const message = Envapter.resolve`Service endpoint: ${'API_URL'}`;
+   * // Returns: "Service endpoint: https://api.example.com:8080"
+   * ```
+   */
+  static resolve(strings: TemplateStringsArray, ...keys: string[]): string;
+  /**
+   * @see {@link Envapter.resolve}
+   */
+  resolve(strings: TemplateStringsArray, ...keys: string[]): string;
+  /**
+   * Assert that one or more environment variables are present and non-empty (post-trim,
+   * after template resolution). Throws `MissingEnvValue` listing every missing key.
+   *
+   * For typed fail-fast in functional code, use `Envapter.getUsing(key, { converter, required: true })`.
+   *
+   * @example
+   * ```ts
+   * Envapter.require('DATABASE_URL');
+   * Envapter.require('DATABASE_URL', 'API_KEY', 'SENTRY_DSN');
+   * ```
+   */
+  static require(...keys: [string, ...string[]]): void;
+  private static resolveAndValidate;
+  /**
+   * @see {@link Envapter.require}
+   */
+  require(...keys: [string, ...string[]]): void;
+}
+//#endregion
+export { Envapter };
+//# sourceMappingURL=Envapter.d.mts.map

package/dist/workerd/Envapter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Envapter.d.mts","names":[],"sources":["../../src/Envapter.ts"],"mappings":";;;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;cAAa,QAAA,SAAiB,eAAA;EA4EX;AAAA;;;;;;;;;;;;;;EAAA,OA5DR,OAAA,CAAQ,OAAA,EAAS,oBAAA,KAAyB,IAAA;;;;EAmBjD,OAAA,CAAQ,OAAA,EAAS,oBAAA,KAAyB,IAAA;;;;;;;;;;;;;SAgBnC,OAAA,CAAA,GAAW,IAAA;EAAA,eAcH,kBAAA;;;;EAWf,OAAA,CAAA,GAAW,IAAA;AAAA"}

package/dist/workerd/Envapter.mjs

@@ -0,0 +1,2 @@
+import{EnvaptError as e}from"./Error.mjs";import"./core/EnvapterBase.mjs";import"./core/EnvironmentMethods.mjs";import{AdvancedMethods as t}from"./core/AdvancedMethods.mjs";var n=class n extends t{static resolve(t,...r){let i=n.strict;return t.reduce((t,n,a)=>{let o=r[a];if(!o)return t+n;let s=super.get(o,``);if(i&&s.trim()===``)throw new e(305,`Cannot resolve template variable "\${${o}}": value is missing or empty.`);return t+n+s},``)}resolve(e,...t){return n.resolve(e,...t)}static require(...t){let r=[];for(let e of t)n.resolveAndValidate(e)===void 0&&r.push(e);if(r.length>0)throw new e(305,`Missing required environment variables: ${r.join(`, `)}.`)}static resolveAndValidate(e){let{value:t}=this.resolveKeyInput(e);if(t===void 0)return;let n=this.templateResolver.resolveTemplate(e,t);if(n.trim()!==``)return n}require(...e){n.require(...e)}};export{n as Envapter};
+//# sourceMappingURL=Envapter.mjs.map

package/dist/workerd/Envapter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Envapter.mjs","names":[],"sources":["../../src/Envapter.ts"],"sourcesContent":["import { AdvancedMethods } from './core';\nimport { EnvaptError, EnvaptErrorCodes } from './Error';\n\nexport { EnvaptCache, Environment } from './core';\n\n/**\n * Main configuration class for environment variable management.\n *\n * Provides both static and instance methods for retrieving typed environment variables\n * with support for template resolution, multiple .env files, and environment detection.\n *\n * Extend your own classes from this to define properties with \\@Envapt decorators and get access to environment-variable methods.\n *\n * @example\n * ```ts\n * // Static usage\n * const port = Envapter.getNumber('PORT', 3000);\n * const url = Envapter.get('API_URL', 'http://localhost');\n * const replica = Envapter.get(['READONLY_URL', 'DATABASE_URL'], 'sqlite://memory');\n *\n * // Instance usage\n * const env = new Envapter();\n * const dbUrl = env.get('DATABASE_URL', 'sqlite://memory');\n * const primaryHost = env.get(['PRIMARY_HOST', 'SECONDARY_HOST']);\n * ```\n *\n * @public\n */\nexport class Envapter extends AdvancedMethods {\n    /**\n     * Tagged template literal for resolving environment variables in template strings.\n     *\n     * @example\n     * ```ts\n     * // Given API_HOST=api.example.com and API_PORT=8080 in environment\n     * const endpoint = Envapter.resolve`Connecting to ${'API_HOST'}:${'API_PORT'}`;\n     * // Returns: \"Connecting to api.example.com:8080\"\n     *\n     * // Works with template variables in .env too:\n     * // API_URL=https://${API_HOST}:${API_PORT}\n     * const message = Envapter.resolve`Service endpoint: ${'API_URL'}`;\n     * // Returns: \"Service endpoint: https://api.example.com:8080\"\n     * ```\n     */\n    static resolve(strings: TemplateStringsArray, ...keys: string[]): string {\n        const strict = Envapter.strict;\n        return strings.reduce((result, string, i) => {\n            const envKey = keys[i];\n            if (!envKey) return result + string;\n            const raw = super.get(envKey, '');\n            if (strict && raw.trim() === '') {\n                throw new EnvaptError(\n                    EnvaptErrorCodes.MissingEnvValue,\n                    `Cannot resolve template variable \"\\${${envKey}}\": value is missing or empty.`\n                );\n            }\n            return result + string + raw;\n        }, '');\n    }\n\n    /**\n     * @see {@link Envapter.resolve}\n     */\n    resolve(strings: TemplateStringsArray, ...keys: string[]): string {\n        return Envapter.resolve(strings, ...keys);\n    }\n\n    /**\n     * Assert that one or more environment variables are present and non-empty (post-trim,\n     * after template resolution). Throws `MissingEnvValue` listing every missing key.\n     *\n     * For typed fail-fast in functional code, use `Envapter.getUsing(key, { converter, required: true })`.\n     *\n     * @example\n     * ```ts\n     * Envapter.require('DATABASE_URL');\n     * Envapter.require('DATABASE_URL', 'API_KEY', 'SENTRY_DSN');\n     * ```\n     */\n    static require(...keys: [string, ...string[]]): void {\n        const missing: string[] = [];\n        for (const k of keys) {\n            if (Envapter.resolveAndValidate(k) === undefined) missing.push(k);\n        }\n\n        if (missing.length > 0) {\n            throw new EnvaptError(\n                EnvaptErrorCodes.MissingEnvValue,\n                `Missing required environment variables: ${missing.join(', ')}.`\n            );\n        }\n    }\n\n    private static resolveAndValidate(key: string): string | undefined {\n        const { value } = this.resolveKeyInput(key);\n        if (value === undefined) return undefined;\n        const resolved = this.templateResolver.resolveTemplate(key, value);\n        if (resolved.trim() === '') return undefined;\n        return resolved;\n    }\n\n    /**\n     * @see {@link Envapter.require}\n     */\n    require(...keys: [string, ...string[]]): void {\n        Envapter.require(...keys);\n    }\n}\n"],"mappings":"6KA4BA,IAAa,EAAb,MAAa,UAAiB,CAAgB,CAgB1C,OAAO,QAAQ,EAA+B,GAAG,EAAwB,CACrE,IAAM,EAAS,EAAS,OACxB,OAAO,EAAQ,QAAQ,EAAQ,EAAQ,IAAM,CACzC,IAAM,EAAS,EAAK,GACpB,GAAI,CAAC,EAAQ,OAAO,EAAS,EAC7B,IAAM,EAAM,MAAM,IAAI,EAAQ,EAAE,EAChC,GAAI,GAAU,EAAI,KAAK,IAAM,GACzB,MAAM,IAAI,EAAA,IAEN,wCAAwC,EAAO,+BACnD,EAEJ,OAAO,EAAS,EAAS,CAC7B,EAAG,EAAE,CACT,CAKA,QAAQ,EAA+B,GAAG,EAAwB,CAC9D,OAAO,EAAS,QAAQ,EAAS,GAAG,CAAI,CAC5C,CAcA,OAAO,QAAQ,GAAG,EAAmC,CACjD,IAAM,EAAoB,CAAC,EAC3B,IAAK,IAAM,KAAK,EACR,EAAS,mBAAmB,CAAC,IAAM,IAAA,IAAW,EAAQ,KAAK,CAAC,EAGpE,GAAI,EAAQ,OAAS,EACjB,MAAM,IAAI,EAAA,IAEN,2CAA2C,EAAQ,KAAK,IAAI,EAAE,EAClE,CAER,CAEA,OAAe,mBAAmB,EAAiC,CAC/D,GAAM,CAAE,SAAU,KAAK,gBAAgB,CAAG,EAC1C,GAAI,IAAU,IAAA,GAAW,OACzB,IAAM,EAAW,KAAK,iBAAiB,gBAAgB,EAAK,CAAK,EAC7D,KAAS,KAAK,IAAM,GACxB,OAAO,CACX,CAKA,QAAQ,GAAG,EAAmC,CAC1C,EAAS,QAAQ,GAAG,CAAI,CAC5B,CACJ"}

package/dist/workerd/Error.d.mts

@@ -0,0 +1,72 @@
+import { StandardSchemaV1 } from "./StandardSchema.mjs";
+
+//#region src/Error.d.ts
+declare enum EnvaptErrorCodes {
+  /** Thrown when an invalid fallback value is provided */
+  InvalidFallback = 101,
+  /** Thrown when fallback value type doesn't match expected converter type */
+  InvalidFallbackType = 102,
+  /** Thrown when array fallback contains elements of wrong type */
+  ArrayFallbackElementTypeMismatch = 103,
+  /** Thrown when fallback type doesn't match the specified converter */
+  FallbackConverterTypeMismatch = 104,
+  /** Thrown when a time-string fallback is malformed (does not match the required `<number><unit>` format) */
+  MalformedTimeFallback = 105,
+  /** Thrown when invalid array converter configuration is provided */
+  InvalidArrayConverterType = 201,
+  /** Thrown when an invalid built-in converter is specified */
+  InvalidBuiltInConverter = 202,
+  /** Thrown when a custom converter is not a function */
+  InvalidCustomConverter = 203,
+  /** Thrown when converter type is not recognized */
+  InvalidConverterType = 204,
+  /** Thrown when primitive type coercion on fallback value fails */
+  PrimitiveCoercionFailed = 205,
+  /** Thrown when an array element fails to convert to the configured element type */
+  ArrayElementConversionFailed = 206,
+  /** Thrown under strict mode when an array element is empty or whitespace only */
+  EmptyArrayElement = 207,
+  /** Thrown when a Standard Schema returns issues for a non-empty env value */
+  SchemaValidationFailed = 208,
+  /** Thrown when a Standard Schema's `validate` itself throws (e.g. a refinement that crashes) */
+  SchemaThrew = 209,
+  /** Thrown when delimiter is missing in array converter configuration */
+  MissingDelimiter = 301,
+  /** Thrown when invalid user-defined configuration is provided */
+  InvalidUserDefinedConfig = 302,
+  /** Thrown when specified environment files don't exist */
+  EnvFilesNotFound = 303,
+  /** Thrown when no valid environment key is provided */
+  InvalidKeyInput = 304,
+  /** Thrown when a required environment value is missing or empty (post-trim) */
+  MissingEnvValue = 305,
+  /** Thrown when a file-based API (envPaths, baseDir, configureProfiles) is used on a source without filesystem support */
+  FileApiUnsupported = 306,
+  /** Thrown when an environment value is read before a source is bound via Envapter.useSource */
+  NoSourceBound = 307
+}
+interface EnvaptErrorOptions {
+  issues?: readonly StandardSchemaV1.Issue[];
+  cause?: unknown;
+}
+/**
+ * Custom error for better DX and debugging when using Envapt.
+ *
+ * @example
+ * ```ts
+ * throw new EnvaptError(EnvaptErrorCodes.InvalidFallback, "Invalid fallback value provided for environment variable.");
+ * ```
+ */
+declare class EnvaptError extends Error {
+  readonly code: EnvaptErrorCodes;
+  /**
+   * Populated only for {@link EnvaptErrorCodes.SchemaValidationFailed} (208). For every other
+   * code this is `undefined`. Lets callers do `if (err.code === 208) err.issues?.forEach(...)`
+   * without a type cast.
+   */
+  readonly issues: readonly StandardSchemaV1.Issue[] | undefined;
+  constructor(code: EnvaptErrorCodes, message: string, options?: EnvaptErrorOptions);
+}
+//#endregion
+export { EnvaptError, EnvaptErrorCodes };
+//# sourceMappingURL=Error.d.mts.map

package/dist/workerd/Error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Error.d.mts","names":[],"sources":["../../src/Error.ts"],"mappings":";;;aAGY,gBAAA;;EAGR,eAAA;EAHwB;EAKxB,mBAAA;EALwB;EAOxB,gCAAA;EAFA;EAIA,6BAAA;EAAA;EAEA,qBAAA;EAIA;EAAA,yBAAA;EAIA;EAFA,uBAAA;EAMA;EAJA,sBAAA;EAQA;EANA,oBAAA;EAUA;EARA,uBAAA;EAeA;EAbA,4BAAA;EAiBA;EAfA,iBAAA;EAmBA;EAjBA,sBAAA;EAmBa;EAjBb,WAAA;EAoBM;EAfN,gBAAA;;EAEA,wBAAA;EAcA;EAZA,gBAAA;EAYmC;EAVnC,eAAA;EAWK;EATL,eAAA;EAoBS;EAlBT,kBAAA;;EAEA,aAAA;AAAA;AAAA,UAGM,kBAAA;EACN,MAAA,YAAkB,gBAAA,CAAiB,KAAK;EACxC,KAAA;AAAA;;;;;;;;;cAWS,WAAA,SAAoB,KAAA;EAAA,SACb,IAAA,EAAM,gBAAA;EAQc;;;;AAA6C;EAA7C,SAFpB,MAAA,WAAiB,gBAAA,CAAiB,KAAA;cAEtC,IAAA,EAAM,gBAAA,EAAkB,OAAA,UAAiB,OAAA,GAAU,kBAAA;AAAA"}

package/dist/workerd/Error.mjs

@@ -0,0 +1,2 @@
+let e=function(e){return e[e.InvalidFallback=101]=`InvalidFallback`,e[e.InvalidFallbackType=102]=`InvalidFallbackType`,e[e.ArrayFallbackElementTypeMismatch=103]=`ArrayFallbackElementTypeMismatch`,e[e.FallbackConverterTypeMismatch=104]=`FallbackConverterTypeMismatch`,e[e.MalformedTimeFallback=105]=`MalformedTimeFallback`,e[e.InvalidArrayConverterType=201]=`InvalidArrayConverterType`,e[e.InvalidBuiltInConverter=202]=`InvalidBuiltInConverter`,e[e.InvalidCustomConverter=203]=`InvalidCustomConverter`,e[e.InvalidConverterType=204]=`InvalidConverterType`,e[e.PrimitiveCoercionFailed=205]=`PrimitiveCoercionFailed`,e[e.ArrayElementConversionFailed=206]=`ArrayElementConversionFailed`,e[e.EmptyArrayElement=207]=`EmptyArrayElement`,e[e.SchemaValidationFailed=208]=`SchemaValidationFailed`,e[e.SchemaThrew=209]=`SchemaThrew`,e[e.MissingDelimiter=301]=`MissingDelimiter`,e[e.InvalidUserDefinedConfig=302]=`InvalidUserDefinedConfig`,e[e.EnvFilesNotFound=303]=`EnvFilesNotFound`,e[e.InvalidKeyInput=304]=`InvalidKeyInput`,e[e.MissingEnvValue=305]=`MissingEnvValue`,e[e.FileApiUnsupported=306]=`FileApiUnsupported`,e[e.NoSourceBound=307]=`NoSourceBound`,e}({});var t=class extends Error{code;issues;constructor(e,t,n){super(t,n?.cause===void 0?void 0:{cause:n.cause}),this.name=`EnvaptError [${e}]`,this.code=e,this.issues=n?.issues}};export{t as EnvaptError,e as EnvaptErrorCodes};
+//# sourceMappingURL=Error.mjs.map

package/dist/workerd/Error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Error.mjs","names":[],"sources":["../../src/Error.ts"],"sourcesContent":["/* eslint-disable no-magic-numbers */\nimport type { StandardSchemaV1 } from './StandardSchema';\n\nexport enum EnvaptErrorCodes {\n    // Fallback related errors\n    /** Thrown when an invalid fallback value is provided */\n    InvalidFallback = 101,\n    /** Thrown when fallback value type doesn't match expected converter type */\n    InvalidFallbackType = 102,\n    /** Thrown when array fallback contains elements of wrong type */\n    ArrayFallbackElementTypeMismatch = 103,\n    /** Thrown when fallback type doesn't match the specified converter */\n    FallbackConverterTypeMismatch = 104,\n    /** Thrown when a time-string fallback is malformed (does not match the required `<number><unit>` format) */\n    MalformedTimeFallback = 105,\n\n    // Converter related errors\n    /** Thrown when invalid array converter configuration is provided */\n    InvalidArrayConverterType = 201,\n    /** Thrown when an invalid built-in converter is specified */\n    InvalidBuiltInConverter = 202,\n    /** Thrown when a custom converter is not a function */\n    InvalidCustomConverter = 203,\n    /** Thrown when converter type is not recognized */\n    InvalidConverterType = 204,\n    /** Thrown when primitive type coercion on fallback value fails */\n    PrimitiveCoercionFailed = 205,\n    /** Thrown when an array element fails to convert to the configured element type */\n    ArrayElementConversionFailed = 206,\n    /** Thrown under strict mode when an array element is empty or whitespace only */\n    EmptyArrayElement = 207,\n    /** Thrown when a Standard Schema returns issues for a non-empty env value */\n    SchemaValidationFailed = 208,\n    /** Thrown when a Standard Schema's `validate` itself throws (e.g. a refinement that crashes) */\n    SchemaThrew = 209,\n\n    // Other errors\n    /** Thrown when delimiter is missing in array converter configuration */\n    // This doesn't happen because 203 is thrown when object without delimiter is passed\n    MissingDelimiter = 301,\n    /** Thrown when invalid user-defined configuration is provided */\n    InvalidUserDefinedConfig = 302,\n    /** Thrown when specified environment files don't exist */\n    EnvFilesNotFound = 303,\n    /** Thrown when no valid environment key is provided */\n    InvalidKeyInput = 304,\n    /** Thrown when a required environment value is missing or empty (post-trim) */\n    MissingEnvValue = 305,\n    /** Thrown when a file-based API (envPaths, baseDir, configureProfiles) is used on a source without filesystem support */\n    FileApiUnsupported = 306,\n    /** Thrown when an environment value is read before a source is bound via Envapter.useSource */\n    NoSourceBound = 307\n}\n\ninterface EnvaptErrorOptions {\n    issues?: readonly StandardSchemaV1.Issue[];\n    cause?: unknown;\n}\n\n/**\n * Custom error for better DX and debugging when using Envapt.\n *\n * @example\n * ```ts\n * throw new EnvaptError(EnvaptErrorCodes.InvalidFallback, \"Invalid fallback value provided for environment variable.\");\n * ```\n */\nexport class EnvaptError extends Error {\n    public readonly code: EnvaptErrorCodes;\n    /**\n     * Populated only for {@link EnvaptErrorCodes.SchemaValidationFailed} (208). For every other\n     * code this is `undefined`. Lets callers do `if (err.code === 208) err.issues?.forEach(...)`\n     * without a type cast.\n     */\n    public readonly issues: readonly StandardSchemaV1.Issue[] | undefined;\n\n    constructor(code: EnvaptErrorCodes, message: string, options?: EnvaptErrorOptions) {\n        super(message, options?.cause !== undefined ? { cause: options.cause } : undefined);\n        this.name = `EnvaptError [${code}]`;\n        this.code = code;\n        this.issues = options?.issues;\n    }\n}\n"],"mappings":"AAGA,IAAY,EAAL,SAAA,EAAA,OAGH,GAAA,EAAA,gBAAA,KAAA,kBAEA,EAAA,EAAA,oBAAA,KAAA,sBAEA,EAAA,EAAA,iCAAA,KAAA,mCAEA,EAAA,EAAA,8BAAA,KAAA,gCAEA,EAAA,EAAA,sBAAA,KAAA,wBAIA,EAAA,EAAA,0BAAA,KAAA,4BAEA,EAAA,EAAA,wBAAA,KAAA,0BAEA,EAAA,EAAA,uBAAA,KAAA,yBAEA,EAAA,EAAA,qBAAA,KAAA,uBAEA,EAAA,EAAA,wBAAA,KAAA,0BAEA,EAAA,EAAA,6BAAA,KAAA,+BAEA,EAAA,EAAA,kBAAA,KAAA,oBAEA,EAAA,EAAA,uBAAA,KAAA,yBAEA,EAAA,EAAA,YAAA,KAAA,cAKA,EAAA,EAAA,iBAAA,KAAA,mBAEA,EAAA,EAAA,yBAAA,KAAA,2BAEA,EAAA,EAAA,iBAAA,KAAA,mBAEA,EAAA,EAAA,gBAAA,KAAA,kBAEA,EAAA,EAAA,gBAAA,KAAA,kBAEA,EAAA,EAAA,mBAAA,KAAA,qBAEA,EAAA,EAAA,cAAA,KAAA,iBACJ,EAAA,CAAA,CAAA,EAeA,IAAa,EAAb,cAAiC,KAAM,CACnC,KAMA,OAEA,YAAY,EAAwB,EAAiB,EAA8B,CAC/E,MAAM,EAAS,GAAS,QAAU,IAAA,GAAuC,IAAA,GAA3B,CAAE,MAAO,EAAQ,KAAM,CAAa,EAClF,KAAK,KAAO,gBAAgB,EAAK,GACjC,KAAK,KAAO,EACZ,KAAK,OAAS,GAAS,MAC3B,CACJ"}

package/dist/workerd/StandardSchema.d.mts

@@ -0,0 +1,59 @@
+//#region src/StandardSchema.d.ts
+/**
+ * Standard Schema V1 interface. Inlined verbatim from the spec at https://standardschema.dev
+ * so envapt has zero runtime peer dependencies on any specific schema library
+ * (zod / valibot / arktype / etc).
+ *
+ * envapt narrows usage to SYNCHRONOUS schemas only: env loading is boot-time,
+ * `validate` returning `Promise<Result>` is rejected at the type level (see
+ * `SchemaMustBeSync` brand in `Types.ts`) and at runtime by the Parser dispatch.
+ *
+ * @public
+ */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  interface Props<Input = unknown, Output = Input> {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  interface SuccessResult<Output> {
+    readonly value: Output;
+    readonly issues?: undefined;
+  }
+  interface FailureResult {
+    readonly issues: readonly Issue[];
+  }
+  interface Issue {
+    readonly message: string;
+    readonly path?: readonly (PropertyKey | PathSegment)[] | undefined;
+  }
+  interface PathSegment {
+    readonly key: PropertyKey;
+  }
+  interface Types<Input = unknown, Output = Input> {
+    readonly input: Input;
+    readonly output: Output;
+  }
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+/**
+ * Envapt-side alias for {@link StandardSchemaV1.InferOutput}. Re-exported under a friendlier
+ * name so consumers writing `declare static readonly x: InferSchemaOutput<typeof mySchema>`
+ * don't need the namespace path.
+ * @public
+ */
+type InferSchemaOutput<Schema extends StandardSchemaV1> = StandardSchemaV1.InferOutput<Schema>;
+/**
+ * Envapt-side alias for {@link StandardSchemaV1.InferInput}.
+ * @public
+ */
+type InferSchemaInput<Schema extends StandardSchemaV1> = StandardSchemaV1.InferInput<Schema>;
+//#endregion
+export { InferSchemaInput, InferSchemaOutput, StandardSchemaV1 };
+//# sourceMappingURL=StandardSchema.d.mts.map

package/dist/workerd/StandardSchema.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StandardSchema.d.mts","names":[],"sources":["../../src/StandardSchema.ts"],"mappings":";;AAWA;;;;;;;;;;UAAiB,gBAAA,2BAA2C,KAAA;EAAA,SAC/C,WAAA,EAAa,gBAAA,CAAiB,KAAA,CAAM,KAAA,EAAO,MAAA;AAAA;AAAA,kBAIvC,gBAAA;EAAA,UACI,KAAA,2BAAgC,KAAA;IAAA,SACpC,OAAA;IAAA,SACA,MAAA;IAAA,SACA,QAAA,GAAW,KAAA,cAAmB,MAAA,CAAO,MAAA,IAAU,OAAA,CAAQ,MAAA,CAAO,MAAA;IAAA,SAC9D,KAAA,GAAQ,KAAA,CAAM,KAAA,EAAO,MAAA;EAAA;EAAA,KAGtB,MAAA,WAAiB,aAAA,CAAc,MAAA,IAAU,aAAA;EAAA,UAEpC,aAAA;IAAA,SACJ,KAAA,EAAO,MAAA;IAAA,SACP,MAAA;EAAA;EAAA,UAGI,aAAA;IAAA,SACJ,MAAA,WAAiB,KAAA;EAAA;EAAA,UAGb,KAAA;IAAA,SACJ,OAAA;IAAA,SACA,IAAA,aAAiB,WAAA,GAAc,WAAA;EAAA;EAAA,UAG3B,WAAA;IAAA,SACJ,GAAA,EAAK,WAAA;EAAA;EAAA,UAGD,KAAA,2BAAgC,KAAA;IAAA,SACpC,KAAA,EAAO,KAAA;IAAA,SACP,MAAA,EAAQ,MAAA;EAAA;EAAA,KAGT,UAAA,gBAA0B,gBAAA,IAAoB,WAAA,CAAY,MAAA;EAAA,KAE1D,WAAA,gBAA2B,gBAAA,IAAoB,WAAA,CAAY,MAAA;AAAA;;;;;;;KAS/D,iBAAA,gBAAiC,gBAAA,IAAoB,gBAAA,CAAiB,WAAA,CAAY,MAAA;;;;;KAMlF,gBAAA,gBAAgC,gBAAA,IAAoB,gBAAA,CAAiB,UAAA,CAAW,MAAA"}

package/dist/workerd/TemplateResolver.d.mts

@@ -0,0 +1,17 @@
+import { EnvapterService } from "./types/Env.mjs";
+
+//#region src/TemplateResolver.d.ts
+/**
+ * Resolve `${VAR}` template references in environment values, guarding against circular
+ * references and missing variables.
+ * @internal
+ */
+declare class TemplateResolver {
+  private readonly envService;
+  private readonly TEMPLATE_REGEX;
+  constructor(envService: EnvapterService);
+  resolveTemplate(key: string, value: string, stack?: Set<string>): string;
+}
+//#endregion
+export { TemplateResolver };
+//# sourceMappingURL=TemplateResolver.d.mts.map

package/dist/workerd/TemplateResolver.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TemplateResolver.d.mts","names":[],"sources":["../../src/TemplateResolver.ts"],"mappings":";;;;;AAUA;;;cAAa,gBAAA;EAAA,iBAGoB,UAAA;EAAA,iBAFZ,cAAA;cAEY,UAAA,EAAY,eAAA;EAEzC,eAAA,CAAgB,GAAA,UAAa,KAAA,UAAe,KAAA,GAAO,GAAG;AAAA"}

package/dist/workerd/TemplateResolver.mjs

@@ -0,0 +1,2 @@
+import{EnvaptError as e}from"./Error.mjs";import{debugWarn as t}from"./Debug.mjs";var n=class{envService;TEMPLATE_REGEX=/\${\w*}/g;constructor(e){this.envService=e}resolveTemplate(n,r,i=new Set){i.add(n);let a=this.envService.isStrict(),o=r.replace(this.TEMPLATE_REGEX,r=>{let o=r.slice(2,-1);if(i.has(o))return r;let s=this.envService.getRaw(o);if(s===void 0||s===``||a&&s.trim()===``){if(a)throw new e(305,`Cannot resolve template variable "\${${o}}": value is missing or empty.`);return t(`unresolved template \${${o}} preserved as literal`),r}let c=this.resolveTemplate(o,s,new Set(i));return c.includes(`\${${n}}`)||c===s&&/\$\{[^}]*\}/.test(c)?r:c});return i.delete(n),o}};export{n as TemplateResolver};
+//# sourceMappingURL=TemplateResolver.mjs.map

package/dist/workerd/TemplateResolver.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TemplateResolver.mjs","names":[],"sources":["../../src/TemplateResolver.ts"],"sourcesContent":["import { debugWarn } from './Debug';\nimport { EnvaptError, EnvaptErrorCodes } from './Error';\n\nimport type { EnvapterService } from './types/Env';\n\n/**\n * Resolve `${VAR}` template references in environment values, guarding against circular\n * references and missing variables.\n * @internal\n */\nexport class TemplateResolver {\n    private readonly TEMPLATE_REGEX = /\\${\\w*}/g;\n\n    constructor(private readonly envService: EnvapterService) {}\n\n    resolveTemplate(key: string, value: string, stack: Set<string> = new Set<string>()): string {\n        stack.add(key);\n        const strict = this.envService.isStrict();\n\n        const out = value.replace(this.TEMPLATE_REGEX, (template) => {\n            const variable = template.slice(2, -1);\n\n            if (stack.has(variable)) return template; // cycle, preserve\n\n            const raw = this.envService.getRaw(variable);\n            const isMissing = raw === undefined || raw === '' || (strict && raw.trim() === '');\n            if (isMissing) {\n                if (strict) {\n                    throw new EnvaptError(\n                        EnvaptErrorCodes.MissingEnvValue,\n                        `Cannot resolve template variable \"\\${${variable}}\": value is missing or empty.`\n                    );\n                }\n                debugWarn(`unresolved template \\${${variable}} preserved as literal`);\n                return template; // missing or empty, preserve\n            }\n\n            const resolved = this.resolveTemplate(variable, raw, new Set(stack));\n\n            // If resolution still references the current key, skip replacement (indirect cycle)\n            if (resolved.includes(`\\${${key}}`)) return template;\n\n            // If nothing changed (unresolved placeholders stayed), also preserve original template\n            if (resolved === raw && /\\$\\{[^}]*\\}/.test(resolved)) return template;\n\n            return resolved;\n        });\n\n        stack.delete(key);\n        return out;\n    }\n}\n"],"mappings":"kFAUA,IAAa,EAAb,KAA8B,CAGG,WAF7B,eAAkC,WAElC,YAAY,EAA8C,CAA7B,KAAA,WAAA,CAA8B,CAE3D,gBAAgB,EAAa,EAAe,EAAqB,IAAI,IAAuB,CACxF,EAAM,IAAI,CAAG,EACb,IAAM,EAAS,KAAK,WAAW,SAAS,EAElC,EAAM,EAAM,QAAQ,KAAK,eAAiB,GAAa,CACzD,IAAM,EAAW,EAAS,MAAM,EAAG,EAAE,EAErC,GAAI,EAAM,IAAI,CAAQ,EAAG,OAAO,EAEhC,IAAM,EAAM,KAAK,WAAW,OAAO,CAAQ,EAE3C,GADkB,IAAQ,IAAA,IAAa,IAAQ,IAAO,GAAU,EAAI,KAAK,IAAM,GAChE,CACX,GAAI,EACA,MAAM,IAAI,EAAA,IAEN,wCAAwC,EAAS,+BACrD,EAGJ,OADA,EAAU,0BAA0B,EAAS,uBAAuB,EAC7D,CACX,CAEA,IAAM,EAAW,KAAK,gBAAgB,EAAU,EAAK,IAAI,IAAI,CAAK,CAAC,EAQnE,OALI,EAAS,SAAS,MAAM,EAAI,EAAE,GAG9B,IAAa,GAAO,cAAc,KAAK,CAAQ,EAAU,EAEtD,CACX,CAAC,EAGD,OADA,EAAM,OAAO,CAAG,EACT,CACX,CACJ"}

package/dist/workerd/Validators.mjs

@@ -0,0 +1,2 @@
+import{EnvaptError as e}from"./Error.mjs";import{isArrayOf as t}from"./converters/Converters.mjs";import{BuiltInConverterTypeCheckers as n,ListOfBuiltInConverters as r}from"./converters/ListOfBuiltInConverters.mjs";var i=class{static isBuiltInConverter(e){return typeof e==`string`?r.includes(e):!1}static isArrayConverter(e){return t(e)}static isStandardSchema(e){if(typeof e!=`object`||!e||!(`~standard`in e))return!1;let t=e[`~standard`];if(typeof t!=`object`||!t)return!1;let n=t;return n.version===1&&typeof n.validate==`function`}static customConvertor(t){if(typeof t!=`function`)throw new e(203,`Custom converter must be a function, got ${typeof t}.`)}static arrayConverter(n){if(!t(n))throw new e(201,`Expected an ArrayOf<...> token produced by Converters.array(...)`);if(typeof n.delimiter!=`string`||n.delimiter.length===0)throw new e(301,`ArrayOf<...> requires a non-empty string delimiter, got ${typeof n.delimiter}`);let i=n.of;if(!(typeof i==`string`&&r.includes(i))&&typeof i!=`function`)throw new e(201,`ArrayOf<...> element ("of") must be a built-in scalar token or a function, got ${typeof i}`)}static builtInConverter(t){if(typeof t!=`string`)throw new e(204,`Expected string, got ${typeof t}`);if(!r.includes(t))throw new e(202,`"${t}" is not a valid converter type. Valid types are: ${r.join(`,`)}`)}static validateBuiltInConverterFallback(t,r){let i=n[t];if(!i(r))throw new e(104,`Fallback type does not match converter "${t}". Expected ${t} compatible type.`)}static validateArrayFallbackElementTypes(t){if(t.length===0)return;let n=typeof t[0];if(t.some((e,t)=>t===0?!1:typeof e!==n))throw new e(103,`All elements in array fallback must have the same type. Found mixed types.`)}static validateArrayConverterElementTypeMatch(t,r){if(r.length===0||typeof t==`function`)return;let i=t;if(i===`time`){let t=r.every(e=>typeof e==`number`),n=r.every(e=>typeof e==`string`);if(!t&&!n)throw new e(103,`Time array fallback must be all numbers or all time-string entries.`);return}let a=n[i],o=r[0];if(!a(o))throw new e(103,`Array converter type "${i}" does not match fallback element type. Expected ${i} compatible elements.`)}static isPrimitiveConstructor(e){return e===String||e===Number||e===Boolean||e===BigInt||e===Symbol}static coercePrimitiveFallback(e,t){return this.isCorrectPrimitiveType(e,t)?t:this.performPrimitiveCoercion(e,t)}static isCorrectPrimitiveType(e,t){return e===String&&typeof t==`string`||e===Number&&typeof t==`number`||e===Boolean&&typeof t==`boolean`||e===BigInt&&typeof t==`bigint`||e===Symbol&&typeof t==`symbol`}static performPrimitiveCoercion(t,n){try{if(t===String)return String(n);if(t===Number)return Number(n);if(t===Boolean)return!!n;if(t===BigInt)return BigInt(n);if(t===Symbol)return Symbol.for(String(n))}catch(n){throw new e(205,`Failed to coerce fallback value using ${t.name}: ${n.message}`)}throw new e(205,`Unknown primitive converter: ${t.name}`)}static validateSyncProcessEnv(t){if(typeof t!=`boolean`)throw new e(302,`Envapter.syncProcessEnv must be a boolean, got ${typeof t}.`)}static validateEnvFileOptions(t){let n=new Set([`encoding`,`override`]),r=Object.keys(t).filter(e=>!n.has(e));if(r.length>0)throw new e(302,`Invalid envFileOptions: ${r.join(`, `)}. Allowed options: ${Array.from(n).join(`, `)}. For debug output, use Envapter.debug or the ENVAPT_DEBUG env var.`);return!0}static validateEnvFilesExist(t,n){let r=t.filter(e=>!n(e));if(r.length>0)throw new e(303,`Environment file not found at path: ${r.join(`, `)}`)}};export{i as Validator};
+//# sourceMappingURL=Validators.mjs.map

package/dist/workerd/Validators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Validators.mjs","names":[],"sources":["../../src/Validators.ts"],"sourcesContent":["// Import the converter modules directly, not via the `./converters` barrel: that barrel pulls in\n// ValueConverter, which imports this Validator, so a barrel import here would cycle.\nimport { isArrayOf } from './converters/Converters';\nimport { ListOfBuiltInConverters, BuiltInConverterTypeCheckers } from './converters/ListOfBuiltInConverters';\nimport { EnvaptError, EnvaptErrorCodes } from './Error';\n\nimport type { ArrayOf, ConverterToken } from './converters/Converters';\nimport type { EnvFileOptions } from './Dotenv';\nimport type { StandardSchemaV1 } from './StandardSchema';\nimport type { BuiltInConverter, ConverterFunction, EnvaptConverter } from './types';\n\nexport class Validator {\n    /**\n     * Check if a value is a built-in scalar converter token\n     */\n    static isBuiltInConverter<TFallback>(value: EnvaptConverter<TFallback>): value is BuiltInConverter {\n        if (typeof value === 'string') return ListOfBuiltInConverters.includes(value);\n        return false;\n    }\n\n    /**\n     * Check if a value is an `ArrayOf<...>` token produced by {@link Converters.array}.\n     */\n    static isArrayConverter(value: unknown): value is ArrayOf {\n        return isArrayOf(value);\n    }\n\n    // Structural check: `version === 1` + callable `validate` is the minimum dispatchable\n    // shape per the Standard Schema spec.\n    static isStandardSchema(value: unknown): value is StandardSchemaV1 {\n        if (typeof value !== 'object' || value === null) return false;\n        if (!('~standard' in value)) return false;\n        const slot = (value as { '~standard': unknown })['~standard'];\n        if (typeof slot !== 'object' || slot === null) return false;\n        const props = slot as { version?: unknown; validate?: unknown };\n        return props.version === 1 && typeof props.validate === 'function';\n    }\n\n    static customConvertor<TFallback>(\n        converter: EnvaptConverter<TFallback>\n    ): asserts converter is ConverterFunction<TFallback> {\n        if (typeof converter !== 'function') {\n            throw new EnvaptError(\n                EnvaptErrorCodes.InvalidCustomConverter,\n                `Custom converter must be a function, got ${typeof converter}.`\n            );\n        }\n    }\n\n    /**\n     * Runtime validation that the `ArrayOf<...>` configuration is well-formed.\n     */\n    static arrayConverter(value: unknown): asserts value is ArrayOf {\n        if (!isArrayOf(value)) {\n            throw new EnvaptError(\n                EnvaptErrorCodes.InvalidArrayConverterType,\n                'Expected an ArrayOf<...> token produced by Converters.array(...)'\n            );\n        }\n\n        if (typeof value.delimiter !== 'string' || value.delimiter.length === 0) {\n            throw new EnvaptError(\n                EnvaptErrorCodes.MissingDelimiter,\n                `ArrayOf<...> requires a non-empty string delimiter, got ${typeof value.delimiter}`\n            );\n        }\n\n        const elementOf = value.of;\n        const isScalar = typeof elementOf === 'string' && ListOfBuiltInConverters.includes(elementOf as ConverterToken);\n        const isCustomFn = typeof elementOf === 'function';\n        if (!isScalar && !isCustomFn) {\n            throw new EnvaptError(\n                EnvaptErrorCodes.InvalidArrayConverterType,\n                `ArrayOf<...> element (\"of\") must be a built-in scalar token or a function, got ${typeof elementOf}`\n            );\n        }\n    }\n\n    /**\n     * Validate that a string is a valid built-in scalar converter token\n     */\n    static builtInConverter(value: unknown): asserts value is BuiltInConverter {\n        if (typeof value !== 'string') {\n            throw new EnvaptError(EnvaptErrorCodes.InvalidConverterType, `Expected string, got ${typeof value}`);\n        }\n\n        if (!ListOfBuiltInConverters.includes(value as ConverterToken)) {\n            throw new EnvaptError(\n                EnvaptErrorCodes.InvalidBuiltInConverter,\n                `\"${value}\" is not a valid converter type. Valid types are: ${ListOfBuiltInConverters.join(',')}`\n            );\n        }\n    }\n\n    /**\n     * Validate that fallback type matches the converter's return type for built-in converters\n     */\n    static validateBuiltInConverterFallback(converter: BuiltInConverter, fallback: unknown): void {\n        const typeChecker = BuiltInConverterTypeCheckers[converter];\n        if (!typeChecker(fallback)) {\n            throw new EnvaptError(\n                EnvaptErrorCodes.FallbackConverterTypeMismatch,\n                `Fallback type does not match converter \"${converter}\". Expected ${converter} compatible type.`\n            );\n        }\n    }\n\n    /**\n     * Validate that all elements in an array fallback have consistent types\n     */\n    static validateArrayFallbackElementTypes(fallback: unknown[]): void {\n        if (fallback.length === 0) return;\n\n        const firstElementType = typeof fallback[0];\n        const hasInconsistentTypes = fallback.some((element, index) => {\n            if (index === 0) return false;\n            return typeof element !== firstElementType;\n        });\n\n        if (hasInconsistentTypes) {\n            throw new EnvaptError(\n                EnvaptErrorCodes.ArrayFallbackElementTypeMismatch,\n                `All elements in array fallback must have the same type. Found mixed types.`\n            );\n        }\n    }\n\n    /**\n     * Validate that an `ArrayOf<...>` element converter matches the runtime types of its\n     * fallback elements. For `Converters.Time` arrays the element-time-string format is also\n     * checked here.\n     */\n    static validateArrayConverterElementTypeMatch(elementOf: ArrayOf['of'], fallback: unknown[]): void {\n        if (fallback.length === 0) return;\n\n        if (typeof elementOf === 'function') {\n            // Custom element converters can return anything; we can't statically validate the fallback shape.\n            return;\n        }\n\n        const elementToken = elementOf;\n\n        // Time array fallbacks may be number[] OR string[] (TimeFallback[]).\n        if (elementToken === 'time') {\n            const everyNumber = fallback.every((v) => typeof v === 'number');\n            const everyString = fallback.every((v) => typeof v === 'string');\n            if (!everyNumber && !everyString) {\n                throw new EnvaptError(\n                    EnvaptErrorCodes.ArrayFallbackElementTypeMismatch,\n                    'Time array fallback must be all numbers or all time-string entries.'\n                );\n            }\n            return;\n        }\n\n        const typeChecker = BuiltInConverterTypeCheckers[elementToken];\n        const firstElement = fallback[0];\n        if (!typeChecker(firstElement)) {\n            throw new EnvaptError(\n                EnvaptErrorCodes.ArrayFallbackElementTypeMismatch,\n                `Array converter type \"${elementToken}\" does not match fallback element type. Expected ${elementToken} compatible elements.`\n            );\n        }\n    }\n\n    /**\n     * Check if a value is a primitive constructor\n     */\n    static isPrimitiveConstructor(\n        value: unknown\n    ): value is typeof String | typeof Number | typeof Boolean | typeof BigInt | typeof Symbol {\n        return value === String || value === Number || value === Boolean || value === BigInt || value === Symbol;\n    }\n\n    /**\n     * Safely coerce a fallback value using a primitive constructor\n     */\n    static coercePrimitiveFallback<CoercedType>(\n        converter: typeof String | typeof Number | typeof Boolean | typeof BigInt | typeof Symbol,\n        fallback: unknown\n    ): CoercedType {\n        if (this.isCorrectPrimitiveType(converter, fallback)) return fallback as CoercedType;\n        return this.performPrimitiveCoercion<CoercedType>(converter, fallback);\n    }\n\n    private static isCorrectPrimitiveType(\n        converter: typeof String | typeof Number | typeof Boolean | typeof BigInt | typeof Symbol,\n        fallback: unknown\n    ): boolean {\n        if (converter === String && typeof fallback === 'string') return true;\n        if (converter === Number && typeof fallback === 'number') return true;\n        if (converter === Boolean && typeof fallback === 'boolean') return true;\n        if (converter === BigInt && typeof fallback === 'bigint') return true;\n        if (converter === Symbol && typeof fallback === 'symbol') return true;\n        return false;\n    }\n\n    private static performPrimitiveCoercion<CoercedType>(\n        converter: typeof String | typeof Number | typeof Boolean | typeof BigInt | typeof Symbol,\n        fallback: unknown\n    ): CoercedType {\n        try {\n            if (converter === String) return String(fallback) as CoercedType;\n            if (converter === Number) return Number(fallback) as CoercedType;\n            if (converter === Boolean) return Boolean(fallback) as CoercedType;\n            if (converter === BigInt) return BigInt(fallback as string | number | bigint) as CoercedType;\n            /* v8 ignore next -- @preserve */\n            if (converter === Symbol) return Symbol.for(String(fallback)) as CoercedType;\n        } catch (error) {\n            throw new EnvaptError(\n                EnvaptErrorCodes.PrimitiveCoercionFailed,\n                `Failed to coerce fallback value using ${converter.name}: ${(error as Error).message}`\n            );\n        }\n\n        /* v8 ignore next -- @preserve */\n        throw new EnvaptError(\n            EnvaptErrorCodes.PrimitiveCoercionFailed,\n            `Unknown primitive converter: ${converter.name}`\n        );\n    }\n\n    /**\n     * Reject non-boolean inputs to `Envapter.syncProcessEnv` so a truthy typo\n     * (`'true'`, `1`, etc.) does not silently enable the mirror.\n     */\n    static validateSyncProcessEnv(value: unknown): asserts value is boolean {\n        if (typeof value !== 'boolean') {\n            throw new EnvaptError(\n                EnvaptErrorCodes.InvalidUserDefinedConfig,\n                `Envapter.syncProcessEnv must be a boolean, got ${typeof value}.`\n            );\n        }\n    }\n\n    /**\n     * Make sure the user hasn't provided prohibited options in their dotenv config\n     */\n    static validateEnvFileOptions(config: object): config is EnvFileOptions {\n        const validKeys = new Set(['encoding', 'override']);\n        const invalidKeys = Object.keys(config).filter((key) => !validKeys.has(key));\n\n        if (invalidKeys.length > 0) {\n            throw new EnvaptError(\n                EnvaptErrorCodes.InvalidUserDefinedConfig,\n                `Invalid envFileOptions: ${invalidKeys.join(', ')}. Allowed options: ${Array.from(validKeys).join(', ')}. For debug output, use Envapter.debug or the ENVAPT_DEBUG env var.`\n            );\n        }\n\n        return true;\n    }\n\n    // Existence is probed through the caller-supplied `fileExists` (backed by the bound source) so\n    // this stays free of `node:fs`.\n    static validateEnvFilesExist(paths: string[], fileExists: (path: string) => boolean): void {\n        const missing = paths.filter((p) => !fileExists(p));\n\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"],"mappings":"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"}

package/dist/workerd/converters/BuiltInConverters.mjs

@@ -0,0 +1,2 @@
+import{EnvaptError as e}from"../Error.mjs";const t=1e3,n=60*t,r=60*n,i=24*r,a={ms:1,s:t,m:n,h:r,d:i,w:7*i},o=new RegExp(String.raw`^(\d+(?:\.\d+)?)(ms|s|m|h|d|w)?$`,`u`),s=new RegExp(String.raw`^(\d+(?:\.\d+)?)(ms|s|m|h|d|w)$`,`u`);function c(e,t=!1){let n=e.match(t?s:o);if(!n)return;let[,r,i]=n;if(!r)return;let c=Number.parseFloat(r);if(!Number.isNaN(c))return c*a[i??`ms`]}var l=class t{static string(e,t){return String(e)}static number(e,t){let n=Number(e);return Number.isNaN(n)?t:n}static boolean(e,t){let n=e.toLowerCase().trim();return[`1`,`yes`,`true`,`on`].includes(n)?!0:[`0`,`no`,`false`,`off`].includes(n)?!1:t}static bigint(e,t){try{return BigInt(e)}catch{return t}}static symbol(e,t){try{return e?Symbol.for(e):t}catch{return t}}static integer(e,t){let n=Number.parseInt(e,10);return Number.isNaN(n)?t:n}static float(e,t){let n=Number.parseFloat(e);return Number.isNaN(n)?t:n}static json(e,t){try{return JSON.parse(e)}catch{return t}}static url(e,t){try{return new URL(e)}catch{return t}}static regexp(e,t){try{let t=e.match(new RegExp(String.raw`^\/(.+)\/([gimsuvy]*)$`));return t?new RegExp(t[1],t[2]):new RegExp(e)}catch{return t}}static date(e,t){if(new RegExp(String.raw`^\d+$`).test(e)){let n=new Date(parseInt(e,10));return Number.isNaN(n.getTime())?t:n}if(!new RegExp(String.raw`^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$`,`u`).test(e))return t;let n=new Date(e);return Number.isNaN(n.getTime())?t:n}static time(t,n){let r=c(t);if(r!==void 0)return r;if(typeof n==`number`)return n;if(typeof n==`string`){let t=c(n,!0);if(t===void 0)throw new e(105,`Time-string fallback "${n}" is not a valid format. Expected <number><unit> where unit is one of: ms, s, m, h, d, w.`);return t}}static processArrayConverter(n,r,i=!1){if(n.trim()===``)return[];let a=n.split(r.delimiter).map(e=>String(e).trim());if(i){let t=a.findIndex(e=>e===``);if(t!==-1)throw new e(207,`Array element at index ${t} is empty or whitespace only (strict mode).`)}let o=a.filter(Boolean);if(!o.length)return[];let s=r.of;if(typeof s==`function`)return o.map((t,n)=>{let r=s(t);if(r===void 0)throw new e(206,`Custom element converter returned undefined for item "${t}" at index ${n}.`);return r});let c=t.getConverter(s);return o.map((t,n)=>{let r=c(t,void 0);if(r===void 0)throw new e(206,`Element "${t}" at index ${n} could not be converted to ${s}.`);return r})}static getConverter(e){return{string:t.string,number:t.number,boolean:t.boolean,integer:t.integer,bigint:t.bigint,symbol:t.symbol,float:t.float,json:t.json,url:t.url,regexp:t.regexp,date:t.date,time:t.time}[e]}};export{l as BuiltInConverters};
+//# sourceMappingURL=BuiltInConverters.mjs.map