typed-settings 0.1.1 → 0.2.1

package/dist/chunk-RCO6K3WQ.js

@@ -1,984 +0,0 @@
-import { parseJsonText } from './chunk-33M5GIKQ.js';
-import { parseTomlText } from './chunk-OVFMKC2O.js';
-import { parseYamlText } from './chunk-UFUHHR2J.js';
-import { ConfigError, redactValue, byteLengthUtf8 } from './chunk-EE6LXNJV.js';
-import { parseEnvText } from './chunk-F6DX3HXZ.js';
-
-// src/expand.ts
-var NAME_RE = "[A-Za-z_][A-Za-z0-9_]*";
-function expandValue(input, lookup, opts) {
-  let out = "";
-  let i = 0;
-  while (i < input.length) {
-    const c = input[i];
-    if (c === "$" && input[i + 1] === "$") {
-      out += "$";
-      i += 2;
-      continue;
-    }
-    if (c === "\\" && input[i + 1] === "$") {
-      out += "$";
-      i += 2;
-      continue;
-    }
-    if (c !== "$") {
-      out += c;
-      i++;
-      continue;
-    }
-    const rest = input.slice(i);
-    if (rest.startsWith("${")) {
-      const parsed = parseBraced(input, i);
-      if (!parsed) {
-        out += "$";
-        i++;
-        continue;
-      }
-      const { name: name2, op, def, end } = parsed;
-      if (op && op !== ":-" && op !== "-") {
-        throw new ConfigError([
-          { path: name2, from: opts?.from ?? "env", message: `E_BAD_OP: only :- and - supported, got ${op}` }
-        ], "E_BAD_OP");
-      }
-      const val2 = lookup(name2);
-      const missing = val2 === void 0 || op === ":-" && val2 === "";
-      if (!missing) {
-        out += val2;
-      } else if (def !== void 0) {
-        out += expandValue(def, lookup, opts);
-      } else if (opts?.allowUnresolved) {
-        out += input.slice(i, end);
-      } else {
-        throw new ConfigError([
-          { path: name2, from: opts?.from ?? "env", message: `E_UNRESOLVED: ${name2} missing (expand)` }
-        ], "E_UNRESOLVED");
-      }
-      i = end;
-      continue;
-    }
-    const m = new RegExp(`^\\$(?<name>${NAME_RE})`).exec(rest);
-    if (!m || !m.groups) {
-      out += "$";
-      i++;
-      continue;
-    }
-    const name = m.groups["name"];
-    const val = lookup(name);
-    if (val === void 0) {
-      if (opts?.allowUnresolved) {
-        out += "$" + name;
-      } else {
-        throw new ConfigError([
-          { path: name, from: opts?.from ?? "env", message: `E_UNRESOLVED: ${name} missing (expand)` }
-        ], "E_UNRESOLVED");
-      }
-    } else {
-      out += val;
-    }
-    i += 1 + name.length;
-  }
-  return out;
-}
-function parseBraced(input, start) {
-  let i = start + 2;
-  const nameMatch = new RegExp(`^(?<name>${NAME_RE})`).exec(input.slice(i));
-  if (!nameMatch?.groups) return null;
-  const name = nameMatch.groups["name"];
-  i += name.length;
-  if (input[i] === "}") return { name, end: i + 1 };
-  if (input[i] === ":") {
-    const two = input.slice(i, i + 2);
-    if (two !== ":-") return { name, op: two[0] + (input[i + 1] ?? ""), def: "", end: input.length };
-    i += 2;
-    const { value, end } = readUntilCloseBrace(input, i);
-    return { name, op: ":-", def: value, end };
-  }
-  if (input[i] === "-") {
-    i += 1;
-    const { value, end } = readUntilCloseBrace(input, i);
-    return { name, op: "-", def: value, end };
-  }
-  return null;
-}
-function readUntilCloseBrace(input, start) {
-  let depth = 0;
-  let i = start;
-  let val = "";
-  while (i < input.length) {
-    if (input[i] === "\\" && input[i + 1] === "}") {
-      val += "}";
-      i += 2;
-      continue;
-    }
-    if (input[i] === "{") depth++;
-    if (input[i] === "}") {
-      if (depth === 0) return { value: val, end: i + 1 };
-      depth--;
-    }
-    val += input[i];
-    i++;
-  }
-  throw new Error("ParseError: unterminated ${}");
-}
-
-// src/coerce.ts
-function tryParseEnvValue(input) {
-  return tryParse(input, true);
-}
-function tryParse(input, allowSplit) {
-  if (typeof input !== "string") return input;
-  const s = input;
-  if (s === "") return "";
-  const low = s.toLowerCase();
-  if (low === "true" || low === "false") return low === "true";
-  if (low === "null") return null;
-  if (low === "undefined") return void 0;
-  if (/^-?\d+$/.test(s)) {
-    const n = Number(s);
-    if (Number.isSafeInteger(n)) return n;
-    return s;
-  }
-  if (/^-?(\d+\.\d*|\.\d+|\d+)(e[+-]?\d+)?$/i.test(s) && s !== "-" && s !== ".") {
-    const n = Number(s);
-    if (Number.isFinite(n)) return n;
-    return s;
-  }
-  if (["yes", "y", "on"].includes(low)) return true;
-  if (["no", "n", "off"].includes(low)) return false;
-  const t = s.trim();
-  if (t.startsWith("{") && t.endsWith("}") || t.startsWith("[") && t.endsWith("]")) {
-    try {
-      return JSON.parse(t);
-    } catch {
-      return input;
-    }
-  }
-  if (allowSplit && s.includes(",")) {
-    const parts = splitCsv(s);
-    if (parts !== null) return parts.map((p) => tryParse(p, false));
-  }
-  return input;
-}
-function splitCsv(s) {
-  const out = [];
-  let cur = "";
-  let quote = null;
-  for (let i = 0; i < s.length; i++) {
-    const c = s[i];
-    if (quote) {
-      if (c === "\\" && i + 1 < s.length) {
-        cur += c + s[i + 1];
-        i++;
-        continue;
-      }
-      if (c === quote) {
-        quote = null;
-        cur += c;
-        continue;
-      }
-      cur += c;
-      continue;
-    }
-    if (c === '"' || c === "'") {
-      quote = c;
-      cur += c;
-      continue;
-    }
-    if (c === "\\" && s[i + 1] === ",") {
-      cur += ",";
-      i++;
-      continue;
-    }
-    if (c === ",") {
-      out.push(cur.trim());
-      cur = "";
-      continue;
-    }
-    cur += c;
-  }
-  if (quote) return null;
-  out.push(cur.trim());
-  return out.map((p) => {
-    if (p.length >= 2 && p.startsWith("'") && p.endsWith("'")) return p.slice(1, -1).replace(/\\,/g, ",");
-    if (p.length >= 2 && p.startsWith('"') && p.endsWith('"')) return p.slice(1, -1);
-    return p.replace(/\\,/g, ",");
-  });
-}
-function coerceDeep(value) {
-  if (typeof value === "string") return tryParseEnvValue(value);
-  if (Array.isArray(value)) return value.map(coerceDeep);
-  if (value && typeof value === "object") {
-    const o = {};
-    for (const [k, v] of Object.entries(value)) o[k] = coerceDeep(v);
-    return o;
-  }
-  return value;
-}
-
-// src/merge.ts
-var FORBIDDEN = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-var INDEX_RE = /^(0|[1-9][0-9]*)$/;
-function stripPrefix(key, prefix) {
-  return key;
-}
-function expandKeys(flat, opts) {
-  const out = {};
-  const topKinds = /* @__PURE__ */ new Map();
-  const kindOf = (top) => {
-    let k = topKinds.get(top);
-    if (!k) {
-      k = { indexed: false, named: false, scalar: false };
-      topKinds.set(top, k);
-    }
-    return k;
-  };
-  const lookupEnvMap = (rawKey) => {
-    if (!opts?.envMap) return void 0;
-    for (const cand of [rawKey, rawKey.toLowerCase(), rawKey.toUpperCase()]) {
-      const hit = opts.envMap[cand];
-      if (hit !== void 0) return hit;
-    }
-    return void 0;
-  };
-  for (const [rawKey, value] of Object.entries(flat)) {
-    if (!/^[A-Za-z0-9_]+$/.test(rawKey)) continue;
-    const escaped = lookupEnvMap(rawKey);
-    const effective = escaped ?? rawKey;
-    if (escaped !== void 0) {
-      const k = effective.toLowerCase();
-      if (FORBIDDEN.has(k)) throw new ConfigError([{ path: rawKey, from: "keys", message: "E_PROTO" }], "E_PROTO");
-      out[k] = value;
-      continue;
-    }
-    const stripped = stripPrefix(rawKey);
-    if (stripped === null) continue;
-    const useKey = stripped;
-    if (useKey.includes("__")) {
-      if (FORBIDDEN.has(useKey.toLowerCase())) throw new ConfigError([{ path: rawKey, from: "keys", message: "E_PROTO: forbidden key" }], "E_PROTO");
-      const parts = useKey.split("__");
-      for (const p of parts) {
-        if (FORBIDDEN.has(p.toLowerCase())) throw new ConfigError([{ path: rawKey, from: "keys", message: "E_PROTO: forbidden key" }], "E_PROTO");
-        if (!p) throw new ConfigError([{ path: rawKey, from: "keys", message: "E_EMPTY_SEGMENT" }], "E_EMPTY_SEGMENT");
-      }
-      const lowered = parts.map((p) => p.toLowerCase());
-      const top = lowered[0];
-      const kind = kindOf(top);
-      const childIsIndex = lowered.length > 1 && INDEX_RE.test(lowered[1]);
-      if (kind.scalar && childIsIndex) {
-        throw new ConfigError(
-          [{ path: rawKey, from: "keys", message: `E_ARRAY_MIX: '${top}' has both scalar/list and indexed (__0) values in the same layer` }],
-          "E_ARRAY_MIX"
-        );
-      }
-      if (childIsIndex) {
-        if (kind.named) {
-          throw new ConfigError(
-            [{ path: rawKey, from: "keys", message: `E_ARRAY_MIX: '${top}' mixes indexed (__0) and named children in the same layer` }],
-            "E_ARRAY_MIX"
-          );
-        }
-        kind.indexed = true;
-      } else if (lowered.length > 1) {
-        if (kind.indexed) {
-          throw new ConfigError(
-            [{ path: rawKey, from: "keys", message: `E_ARRAY_MIX: '${top}' mixes named and indexed (__0) children in the same layer` }],
-            "E_ARRAY_MIX"
-          );
-        }
-        kind.named = true;
-      }
-      setPath(out, lowered, value);
-    } else {
-      const k = useKey.toLowerCase();
-      if (FORBIDDEN.has(k)) throw new ConfigError([{ path: rawKey, from: "keys", message: "E_PROTO" }], "E_PROTO");
-      const kind = kindOf(k);
-      if (kind.indexed) {
-        throw new ConfigError(
-          [{ path: rawKey, from: "keys", message: `E_ARRAY_MIX: '${k}' has both indexed (__0) and scalar/list values in the same layer` }],
-          "E_ARRAY_MIX"
-        );
-      }
-      kind.scalar = true;
-      out[k] = value;
-    }
-  }
-  return out;
-}
-function normalizeIndexedObjects(value, path = "<root>") {
-  if (Array.isArray(value)) return value.map((x, i) => normalizeIndexedObjects(x, `${path}[${i}]`));
-  if (!isPlainObject(value)) return value;
-  const entries = Object.entries(value);
-  const normalized = {};
-  for (const [k, v] of entries) {
-    normalized[k] = normalizeIndexedObjects(v, path === "<root>" ? k : `${path}.${k}`);
-  }
-  if (entries.length > 0 && entries.every(([k]) => INDEX_RE.test(k))) {
-    const idx = entries.map(([k]) => Number(k)).sort((a, b) => a - b);
-    if (idx.length > 1024) {
-      throw new ConfigError([{ path, from: "keys", message: "E_ARRAY_CAP: >1024 elements" }], "E_ARRAY_CAP");
-    }
-    for (let i = 0; i < idx.length; i++) {
-      if (idx[i] !== i) {
-        throw new ConfigError(
-          [{ path, from: "keys", message: `E_SPARSE_ARRAY: indexes [${idx.join(",")}] are not dense 0..${idx.length - 1}` }],
-          "E_SPARSE_ARRAY"
-        );
-      }
-    }
-    return idx.map((_, i) => normalized[String(i)]);
-  }
-  return normalized;
-}
-function setPath(root, parts, value) {
-  let cur = root;
-  for (let i = 0; i < parts.length - 1; i++) {
-    const p = parts[i];
-    const existing = cur[p];
-    if (existing && typeof existing === "object" && !Array.isArray(existing)) {
-      cur = existing;
-    } else {
-      const n = {};
-      cur[p] = n;
-      cur = n;
-    }
-  }
-  cur[parts[parts.length - 1]] = value;
-}
-function isPlainObject(v) {
-  if (!v || typeof v !== "object") return false;
-  const proto = Object.getPrototypeOf(v);
-  return proto === Object.prototype || proto === null;
-}
-function deepMerge(base, override, arrayStrategy = "replace") {
-  if (override === void 0) return base;
-  if (base === void 0) return override;
-  if (override === null) return null;
-  if (Array.isArray(base) && Array.isArray(override)) {
-    if (arrayStrategy === "replace") return override;
-    if (arrayStrategy === "concat") return [...base, ...override];
-    const len = Math.max(base.length, override.length);
-    if (len > 1024) throw new ConfigError([{ path: "<array>", from: "merge", message: "E_ARRAY_CAP: >1024" }], "E_ARRAY_CAP");
-    const out = [];
-    for (let i = 0; i < len; i++) {
-      if (i in override) {
-        out[i] = i in base ? deepMerge(base[i], override[i], arrayStrategy) : override[i];
-      } else if (i in base) {
-        out[i] = base[i];
-      }
-    }
-    for (let i = 0; i < len; i++) {
-      if (!(i in out)) {
-        throw new ConfigError(
-          [{ path: `<array>[${i}]`, from: "merge", message: "E_SPARSE_ARRAY: hole at index " + i }],
-          "E_SPARSE_ARRAY"
-        );
-      }
-    }
-    return out;
-  }
-  if (isPlainObject(base) && isPlainObject(override)) {
-    const out = { ...base };
-    for (const [k, v] of Object.entries(override)) {
-      if (FORBIDDEN.has(k)) throw new ConfigError([{ path: k, from: "merge", message: "E_PROTO" }], "E_PROTO");
-      out[k] = k in out ? deepMerge(out[k], v, arrayStrategy) : v;
-    }
-    return out;
-  }
-  return override;
-}
-
-// src/adapter.ts
-function normalizePath(path) {
-  if (!path || path.length === 0) return "<root>";
-  const parts = [];
-  for (const seg of path) {
-    if (seg !== null && typeof seg === "object" && "key" in seg) {
-      parts.push(String(seg.key));
-    } else {
-      parts.push(String(seg));
-    }
-  }
-  return parts.join(".");
-}
-function validateStandard(schema, input) {
-  let r;
-  try {
-    r = schema["~standard"].validate(input);
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    return { issues: [{ path: "<root>", message: msg }], async: false };
-  }
-  if (typeof r?.then === "function") {
-    const p = r.then(
-      (resolved) => normalizeResult(resolved),
-      (e) => ({ ok: false, issues: [{ path: "<root>", message: e instanceof Error ? e.message : String(e) }] })
-    );
-    return { promise: p };
-  }
-  const n = normalizeResult(r);
-  if (!n.ok) return { issues: n.issues, async: false };
-  return { value: n.value };
-}
-function normalizeResult(r) {
-  if (!r.issues || r.issues.length === 0) {
-    return { ok: true, value: r.value };
-  }
-  return {
-    ok: false,
-    issues: r.issues.map((i) => ({ path: normalizePath(i.path), message: i.message }))
-  };
-}
-
-// src/index.ts
-function getEnvSnapshot(injected) {
-  if (injected) return injected;
-  const g = globalThis;
-  if (g.process?.env) return { ...g.process.env };
-  return {};
-}
-function isSecretKey(key) {
-  return /key|secret|token|password|private/i.test(key);
-}
-function withOverrides(map, fn) {
-  const g = globalThis;
-  const prev = g.process?.env ? { ...g.process.env } : void 0;
-  const restore = () => {
-    if (g.process?.env && prev) {
-      for (const k of Object.keys(g.process.env)) delete g.process.env[k];
-      Object.assign(g.process.env, prev);
-    }
-  };
-  if (g.process?.env) {
-    for (const [k, v] of Object.entries(map)) {
-      if (v === void 0) delete g.process.env[k];
-      else g.process.env[k] = v;
-    }
-  }
-  let out;
-  try {
-    out = fn();
-  } catch (e) {
-    restore();
-    throw e;
-  }
-  if (isThenable(out)) return out.finally(restore);
-  restore();
-  return out;
-}
-function pickPublic(cfg, keys) {
-  const out = {};
-  for (const k of keys) if (k in cfg) out[k] = cfg[k];
-  return out;
-}
-function viteSettings(opts, metaEnv) {
-  return settings({ ...opts, sources: [{ map: metaEnv }], env: {} });
-}
-function readFileSyncSafe(path, maxBytes = 2 * 1024 * 1024) {
-  const getFs = () => {
-    const injected = globalThis.__typedSettingsFs;
-    if (injected) return injected;
-    const g = globalThis;
-    if (g.process) {
-      const fn = new Function('return typeof require !== "undefined" ? require("node:fs") : null')();
-      if (!fn) {
-        throw new ConfigError(
-          [{ path, from: path, message: "E_NO_FS: file sources need `typed-settings/node` under ESM (or pass { text }/{ map })" }],
-          "E_NO_FS"
-        );
-      }
-      return fn;
-    }
-    return null;
-  };
-  try {
-    const fs = getFs();
-    if (!fs) return void 0;
-    const text = fs.readFileSync(path, "utf8");
-    if (byteLengthUtf8(text) > maxBytes) {
-      throw new ConfigError(
-        [{ path, from: path, message: `E_FILE_TOO_LARGE: >${maxBytes} bytes` }],
-        "E_FILE_TOO_LARGE"
-      );
-    }
-    return text;
-  } catch (e) {
-    if (e instanceof ConfigError) throw e;
-    const err = e;
-    if (err?.code === "ENOENT") return void 0;
-    throw e;
-  }
-}
-function parseStructuredFile(path, text) {
-  const lower = path.toLowerCase();
-  try {
-    if (lower.endsWith(".json")) return parseJsonText(text, path);
-    if (lower.endsWith(".yaml") || lower.endsWith(".yml")) return parseYamlText(text, path);
-    return parseTomlText(text, path);
-  } catch (e) {
-    const err = e;
-    throw new ConfigError([{ path, from: path, message: err.message }], "E_PARSE");
-  }
-}
-function stripFlatKey(key, effPrefix) {
-  if (!effPrefix) return key;
-  if (key.length <= effPrefix.length) return null;
-  if (key.slice(0, effPrefix.length).toLowerCase() !== effPrefix.toLowerCase()) return null;
-  return key.slice(effPrefix.length);
-}
-function assertAcyclic(value, label) {
-  const visiting = /* @__PURE__ */ new Set();
-  const visit = (v, path) => {
-    if (!v || typeof v !== "object") return;
-    if (visiting.has(v)) {
-      throw new ConfigError(
-        [{ path, from: label, message: `E_CYCLE: cyclic value at ${path} (from ${label})` }],
-        "E_CYCLE"
-      );
-    }
-    visiting.add(v);
-    try {
-      for (const [k, child] of Object.entries(v)) visit(child, path ? `${path}.${k}` : k);
-    } finally {
-      visiting.delete(v);
-    }
-  };
-  visit(value, "");
-}
-function flatToLayer(m, label, srcPrefix, globalPrefix, opts, skipExpand) {
-  assertAcyclic(m, label);
-  const effPrefix = srcPrefix ?? globalPrefix;
-  const stripped = {};
-  for (const [k, v] of Object.entries(m)) {
-    const s = stripFlatKey(k, effPrefix);
-    if (s === null) continue;
-    stripped[s] = v;
-  }
-  const node = normalizeIndexedObjects(
-    expandKeys(stripped, { envMap: opts.envMap })
-  );
-  return { node, label, skipExpand };
-}
-function structuredToLayer(value, label, prefix) {
-  assertAcyclic(value, label);
-  if (!isPlainObject(value)) return { node: value ?? {}, label, skipExpand: false };
-  const out = {};
-  for (const [k, v] of Object.entries(value)) {
-    if (["__proto__", "constructor", "prototype"].includes(k)) {
-      throw new ConfigError([{ path: k, from: label, message: "E_PROTO: forbidden key" }], "E_PROTO");
-    }
-    if (prefix) {
-      const s = stripFlatKey(k, prefix);
-      if (s === null) continue;
-      out[s] = v;
-    } else {
-      out[k] = v;
-    }
-  }
-  return { node: out, label, skipExpand: false };
-}
-function recordLayerFrom(fromMap, layer) {
-  const node = layer.node;
-  if (node && typeof node === "object" && !Array.isArray(node)) {
-    for (const k of Object.keys(node)) fromMap.set(k.toLowerCase(), layer.label);
-  }
-}
-function isThenable(v) {
-  return !!v && (typeof v === "object" || typeof v === "function") && typeof v.then === "function";
-}
-function asProvider(src) {
-  if (!("provider" in src || "load" in src)) return null;
-  const prov = "provider" in src ? src.provider : src;
-  if (!prov || typeof prov.load !== "function") return null;
-  return { load: prov.load, name: typeof prov.name === "string" ? prov.name : "<provider>" };
-}
-function timeoutError(name) {
-  return new ConfigError([{ path: name, from: name, message: "E_TIMEOUT: provider load timed out" }], "E_TIMEOUT");
-}
-function collectSources(opts, envSnapshot) {
-  const sources = opts.sources ?? [".env", "env"];
-  const prefix = opts.prefix;
-  const layers = [];
-  const fromMap = /* @__PURE__ */ new Map();
-  const maxBytes = opts.maxBytes ?? 2 * 1024 * 1024;
-  const push = (layer) => {
-    layers.push(layer);
-    recordLayerFrom(fromMap, layer);
-  };
-  const parseEnv = (text, label) => {
-    try {
-      return parseEnvText(text);
-    } catch (e) {
-      const err = e;
-      throw new ConfigError([{ path: label, from: label, message: err.message }], "E_PARSE");
-    }
-  };
-  for (const src of sources) {
-    if (src === "env") {
-      push(flatToLayer({ ...envSnapshot }, "env", void 0, prefix, opts, false));
-    } else if (src === ".env" || src === ".env.local") {
-      const text = readFileSyncSafe(src, maxBytes);
-      if (text === void 0) continue;
-      push(flatToLayer(parseEnv(text, src), src, void 0, prefix, opts, false));
-    } else if (typeof src === "string") {
-      const text = readFileSyncSafe(src, maxBytes);
-      if (text === void 0) continue;
-      const lower = src.toLowerCase();
-      if (lower.endsWith(".json") || lower.endsWith(".yaml") || lower.endsWith(".yml") || lower.endsWith(".toml")) {
-        push(structuredToLayer(parseStructuredFile(src, text), src, prefix));
-      } else {
-        push(flatToLayer(parseEnv(text, src), src, void 0, prefix, opts, false));
-      }
-    } else if (src && typeof src === "object" && "text" in src) {
-      push(flatToLayer(parseEnv(src.text, "text"), "text", void 0, prefix, opts, false));
-    } else if (src && typeof src === "object" && "map" in src) {
-      const m = src;
-      push(flatToLayer(m.map ?? {}, "overrides", m.prefix, prefix, opts, false));
-    } else if (src && typeof src === "object" && "file" in src) {
-      const p = src.file;
-      const text = readFileSyncSafe(p, maxBytes);
-      if (text === void 0) continue;
-      const lower = p.toLowerCase();
-      if (lower.endsWith(".json") || lower.endsWith(".yaml") || lower.endsWith(".yml") || lower.endsWith(".toml")) {
-        push(structuredToLayer(parseStructuredFile(p, text), p, prefix));
-      } else {
-        push(flatToLayer(parseEnv(text, p), p, void 0, prefix, opts, false));
-      }
-    } else if (src && typeof src === "object" && "dir" in src) {
-      continue;
-    } else if (src && typeof src === "object") {
-      const prov = asProvider(src);
-      if (prov) {
-        const srcPrefix = "prefix" in src ? src.prefix : void 0;
-        const loaded = prov.load();
-        if (isThenable(loaded)) {
-          throw new ConfigError(
-            [{ path: "<provider>", from: prov.name, message: "USE_ASYNC: provider is async, use settingsAsync()" }],
-            "USE_ASYNC"
-          );
-        }
-        push(flatToLayer(loaded ?? {}, prov.name, srcPrefix, prefix, opts, !opts.expandSecrets));
-      } else {
-        push(flatToLayer(src, "overrides", void 0, prefix, opts, false));
-      }
-    }
-  }
-  return { layers, fromMap };
-}
-async function collectSourcesAsync(opts, envSnapshot) {
-  const timeoutMs = opts.timeoutMs ?? 5e3;
-  const needsAsync = (opts.sources ?? []).some((s) => s && typeof s === "object" && asProvider(s) !== null);
-  if (!needsAsync) return collectSources(opts, envSnapshot);
-  const sources = opts.sources;
-  const prefix = opts.prefix;
-  const layers = [];
-  const fromMap = /* @__PURE__ */ new Map();
-  const maxBytes = opts.maxBytes ?? 2 * 1024 * 1024;
-  const push = (layer) => {
-    layers.push(layer);
-    recordLayerFrom(fromMap, layer);
-  };
-  const parseEnv = (text, label) => {
-    try {
-      return parseEnvText(text);
-    } catch (e) {
-      const err = e;
-      throw new ConfigError([{ path: label, from: label, message: err.message }], "E_PARSE");
-    }
-  };
-  const withTimeout = async (name, fn) => {
-    let t;
-    const timeout = new Promise((_, rej) => {
-      t = setTimeout(() => rej(timeoutError(name)), timeoutMs);
-    });
-    const winner = await Promise.race([Promise.resolve().then(fn), timeout]).catch((e) => {
-      clearTimeout(t);
-      if (e instanceof ConfigError) throw e;
-      const err = e;
-      throw new ConfigError(
-        [{ path: name, from: name, message: `E_PROVIDER: ${err?.message ?? String(e)}` }],
-        "E_PROVIDER"
-      );
-    });
-    clearTimeout(t);
-    return winner;
-  };
-  for (const src of sources) {
-    if (src === "env") {
-      push(flatToLayer({ ...envSnapshot }, "env", void 0, prefix, opts, false));
-    } else if (src === ".env" || src === ".env.local") {
-      const text = readFileSyncSafe(src, maxBytes);
-      if (text === void 0) continue;
-      push(flatToLayer(parseEnv(text, src), src, void 0, prefix, opts, false));
-    } else if (typeof src === "string") {
-      const text = readFileSyncSafe(src, maxBytes);
-      if (text === void 0) continue;
-      const lower = src.toLowerCase();
-      if (lower.endsWith(".json") || lower.endsWith(".yaml") || lower.endsWith(".yml") || lower.endsWith(".toml")) {
-        push(structuredToLayer(parseStructuredFile(src, text), src, prefix));
-      } else {
-        push(flatToLayer(parseEnv(text, src), src, void 0, prefix, opts, false));
-      }
-    } else if (src && typeof src === "object" && "text" in src) {
-      push(flatToLayer(parseEnv(src.text, "text"), "text", void 0, prefix, opts, false));
-    } else if (src && typeof src === "object" && "map" in src) {
-      const m = src;
-      push(flatToLayer(m.map ?? {}, "overrides", m.prefix, prefix, opts, false));
-    } else if (src && typeof src === "object" && "file" in src) {
-      const p = src.file;
-      const text = readFileSyncSafe(p, maxBytes);
-      if (text === void 0) continue;
-      const lower = p.toLowerCase();
-      if (lower.endsWith(".json") || lower.endsWith(".yaml") || lower.endsWith(".yml") || lower.endsWith(".toml")) {
-        push(structuredToLayer(parseStructuredFile(p, text), p, prefix));
-      } else {
-        push(flatToLayer(parseEnv(text, p), p, void 0, prefix, opts, false));
-      }
-    } else if (src && typeof src === "object" && "dir" in src) {
-      continue;
-    } else if (src && typeof src === "object") {
-      const prov = asProvider(src);
-      if (prov) {
-        const srcPrefix = "prefix" in src ? src.prefix : void 0;
-        const loaded = await withTimeout(prov.name, () => prov.load());
-        push(flatToLayer(loaded ?? {}, prov.name, srcPrefix, prefix, opts, !opts.expandSecrets));
-      } else {
-        push(flatToLayer(src, "overrides", void 0, prefix, opts, false));
-      }
-    }
-  }
-  return { layers, fromMap };
-}
-function buildConfigObject(opts, envSnapshot) {
-  const { layers, fromMap } = collectSources(opts, envSnapshot);
-  const arrayStrategy = opts.arrayStrategy ?? "replace";
-  let merged = {};
-  for (const layer of layers) {
-    merged = deepMerge(merged, layer.node, arrayStrategy);
-  }
-  const skipTops = new Set(
-    layers.filter((l) => l.skipExpand).flatMap((l) => Object.keys(l.node)).map((k) => k.toLowerCase())
-  );
-  if (opts.expand !== false) {
-    merged = expandDeepStrings(merged, makeLookup(merged, envSnapshot), {
-      allowUnresolved: opts.allowUnresolved,
-      fromMap,
-      skipTops
-    });
-  }
-  if (opts.coerce !== false) {
-    merged = coerceDeep(merged);
-  }
-  const fromFor = (path) => {
-    const top = path.split(".")[0].toLowerCase();
-    if (top === "<root>") return "schema";
-    return fromMap.get(top) ?? "defaults";
-  };
-  return { input: merged, fromFor };
-}
-function makeLookup(merged, envSnapshot) {
-  const rec = merged && typeof merged === "object" && !Array.isArray(merged) ? merged : {};
-  const ciKeys = new Map(Object.keys(rec).map((k) => [k.toLowerCase(), k]));
-  return (name) => {
-    const hit = ciKeys.get(name.toLowerCase());
-    if (hit !== void 0) {
-      const direct = rec[hit];
-      if (typeof direct === "string") return direct;
-      if (direct !== void 0 && direct !== null) return String(direct);
-    }
-    return envSnapshot[name] ?? envSnapshot[name.toUpperCase()] ?? envSnapshot[name.toLowerCase()];
-  };
-}
-function expandDeepStrings(obj, lookup, ctx, path = []) {
-  if (typeof obj === "string") {
-    const top = (path[0] ?? "<root>").toLowerCase();
-    return expandLeaf(obj, lookup, { ...ctx, from: ctx.fromMap.get(top) ?? "config" }, path.map((p) => p.toLowerCase()));
-  }
-  if (Array.isArray(obj)) return obj.map((x, i) => expandDeepStrings(x, lookup, ctx, [...path, String(i)]));
-  if (obj && typeof obj === "object") {
-    if (path.length === 0) {
-      const o2 = {};
-      for (const [k, v] of Object.entries(obj)) {
-        o2[k] = ctx.skipTops.has(k.toLowerCase()) ? v : expandDeepStrings(v, lookup, ctx, [k]);
-      }
-      return o2;
-    }
-    const o = {};
-    for (const [k, v] of Object.entries(obj)) o[k] = expandDeepStrings(v, lookup, ctx, [...path, k]);
-    return o;
-  }
-  return obj;
-}
-function expandLeaf(value, lookup, ctx, stack) {
-  return expandValue(
-    value,
-    (name) => {
-      const lower = name.toLowerCase();
-      if (stack.includes(lower)) {
-        throw new ConfigError(
-          [{ path: name, from: ctx.from, message: `E_CIRCULAR: $${[...stack, name].join("->$")}` }],
-          "E_CIRCULAR"
-        );
-      }
-      const raw = lookup(name);
-      if (raw === void 0) return void 0;
-      if (raw.includes("$")) return expandLeaf(raw, lookup, ctx, [...stack, lower]);
-      return raw;
-    },
-    { allowUnresolved: ctx.allowUnresolved, from: ctx.from }
-  );
-}
-function collectLeafPaths(v, prefix = "") {
-  if (Array.isArray(v)) {
-    const out = [];
-    v.forEach((x, i) => out.push(...collectLeafPaths(x, prefix ? `${prefix}.${i}` : `${i}`)));
-    return out;
-  }
-  if (isPlainObject(v)) {
-    const out = [];
-    for (const [k, val] of Object.entries(v)) {
-      const p = prefix ? `${prefix}.${k.toLowerCase()}` : k.toLowerCase();
-      if (isPlainObject(val) || Array.isArray(val)) out.push(...collectLeafPaths(val, p));
-      else out.push(p);
-    }
-    return out;
-  }
-  return prefix ? [prefix.toLowerCase()] : [];
-}
-function applyUnknownKeys(input, value, mode) {
-  if (mode === "strip" || mode === void 0) return value;
-  if (mode === "preserve") {
-    if (isPlainObject(input) && isPlainObject(value)) return deepMerge(input, value, "replace");
-    return value;
-  }
-  const inputPaths = new Set(collectLeafPaths(input));
-  const valuePaths = new Set(collectLeafPaths(value));
-  const unknown = [...inputPaths].filter((p) => !valuePaths.has(p));
-  if (unknown.length > 0) {
-    throw new ConfigError(
-      unknown.map((p) => ({ path: p, from: "schema", message: "E_UNKNOWN_KEY: unknown key (unknownKeys=reject)" })),
-      "E_UNKNOWN_KEY"
-    );
-  }
-  return value;
-}
-function freezeDeep(v) {
-  if (Array.isArray(v)) {
-    for (const x of v) freezeDeep(x);
-    return Object.freeze(v);
-  }
-  if (v && typeof v === "object") {
-    for (const k of Object.keys(v)) freezeDeep(v[k]);
-    return Object.freeze(v);
-  }
-  return v;
-}
-function settings(opts) {
-  const envSnapshot = getEnvSnapshot(opts.env);
-  const { input, fromFor } = buildConfigObject(opts, envSnapshot);
-  const r = validateStandard(opts.schema, input);
-  if ("promise" in r) {
-    throw new ConfigError(
-      [{ path: "<root>", from: "schema", message: "USE_ASYNC: schema is async, use settingsAsync()" }],
-      "USE_ASYNC"
-    );
-  }
-  if ("issues" in r) {
-    throw new ConfigError(
-      r.issues.map((i) => ({ path: i.path, from: fromFor(i.path), message: maskIfSecret(i.path, i.message, input) }))
-    );
-  }
-  const value = r.value;
-  const final = applyUnknownKeys(input, value, opts.unknownKeys ?? "strip");
-  return opts.freeze === false ? final : freezeDeep(final);
-}
-async function settingsAsync(opts) {
-  const timeoutMs = opts.timeoutMs ?? 5e3;
-  const envSnapshot = getEnvSnapshot(opts.env);
-  const { input, fromFor } = await buildConfigObjectAsync(opts, envSnapshot);
-  const r = validateStandard(opts.schema, input);
-  if ("promise" in r) {
-    const raced = await Promise.race([
-      r.promise,
-      new Promise((_, rej) => setTimeout(() => rej(new ConfigError([{ path: "<root>", from: "schema", message: "E_TIMEOUT" }], "E_TIMEOUT")), timeoutMs))
-    ]);
-    if (!raced.ok) {
-      throw new ConfigError(raced.issues.map((i) => ({ path: i.path, from: fromFor(i.path), message: maskIfSecret(i.path, i.message, input) })));
-    }
-    const value2 = raced.value;
-    const final2 = applyUnknownKeys(input, value2, opts.unknownKeys ?? "strip");
-    return opts.freeze === false ? final2 : freezeDeep(final2);
-  }
-  if ("issues" in r) {
-    throw new ConfigError(r.issues.map((i) => ({ path: i.path, from: fromFor(i.path), message: maskIfSecret(i.path, i.message, input) })));
-  }
-  const value = r.value;
-  const final = applyUnknownKeys(input, value, opts.unknownKeys ?? "strip");
-  return opts.freeze === false ? final : freezeDeep(final);
-}
-async function buildConfigObjectAsync(opts, envSnapshot) {
-  const { layers, fromMap } = await collectSourcesAsync(opts, envSnapshot);
-  const arrayStrategy = opts.arrayStrategy ?? "replace";
-  let merged = {};
-  for (const layer of layers) {
-    merged = deepMerge(merged, layer.node, arrayStrategy);
-  }
-  const skipTops = new Set(
-    layers.filter((l) => l.skipExpand).flatMap((l) => Object.keys(l.node)).map((k) => k.toLowerCase())
-  );
-  if (opts.expand !== false) {
-    merged = expandDeepStrings(merged, makeLookup(merged, envSnapshot), {
-      allowUnresolved: opts.allowUnresolved,
-      fromMap,
-      skipTops
-    });
-  }
-  if (opts.coerce !== false) merged = coerceDeep(merged);
-  const fromFor = (path) => {
-    const top = path.split(".")[0].toLowerCase();
-    if (top === "<root>") return "schema";
-    return fromMap.get(top) ?? "defaults";
-  };
-  return { input: merged, fromFor };
-}
-function getLeafByPath(input, path) {
-  const parts = path.split(".");
-  let cur = input;
-  for (const part of parts) {
-    if (cur === null || typeof cur !== "object") return void 0;
-    if (Array.isArray(cur)) {
-      const m = /\[(\d+)\]/.exec(part);
-      const idx = m ? Number(m[1]) : Number(part);
-      if (!Number.isInteger(idx)) return void 0;
-      cur = cur[idx];
-      continue;
-    }
-    const rec = cur;
-    const found = Object.keys(rec).find((k) => k.toLowerCase() === part.toLowerCase());
-    if (!found) return void 0;
-    cur = rec[found];
-  }
-  return cur;
-}
-function base64Of(s) {
-  try {
-    const g = globalThis;
-    if (g.btoa) return g.btoa(s);
-    if (g.Buffer) return g.Buffer.from(s, "utf8").toString("base64");
-  } catch {
-  }
-  return null;
-}
-function maskIfSecret(path, message, input) {
-  if (!isSecretKey(path)) return message;
-  let out = message;
-  const leaf = getLeafByPath(input, path);
-  if (typeof leaf === "string" && leaf.length > 0) {
-    const redacted = redactValue(path, leaf);
-    out = out.split(leaf).join(redacted);
-    const b64 = base64Of(leaf);
-    if (b64 && b64.length > 8) out = out.split(b64).join(redacted);
-  }
-  return `${out} (redacted)`;
-}
-
-export { pickPublic, settings, settingsAsync, viteSettings, withOverrides };