varlock 0.0.3 → 0.0.5

package/dist/{chunk-TYL3Q4QG.js → chunk-K2N2TG4M.js}

@@ -1,10 +1,10 @@
 import { __name } from './chunk-XN24GZXQ.js';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
-import fs from 'node:fs/promises';
+import fs2 from 'node:fs/promises';
 import path from 'node:path';
 import { ParsedEnvSpecStaticValue, ParsedEnvSpecFunctionCall, ParsedEnvSpecKeyValuePair, parseEnvSpecDotEnvFile } from '@env-spec/parser';
-import fs2 from 'node:fs';
+import fs from 'node:fs';
 
 // ../../node_modules/.pnpm/@sindresorhus+is@7.0.1/node_modules/@sindresorhus/is/distribution/index.js
 var typedArrayTypeNames = [
@@ -701,7 +701,7 @@ function mapValues(obj, fn) {
 }
 __name(mapValues, "mapValues");
 function times(count, fn) {
-  return Array.from({ length: count }, (_2, i) => fn(i));
+  return Array.from({ length: count }, (_3, i) => fn(i));
 }
 __name(times, "times");
 function map(array, fn) {
@@ -880,1133 +880,677 @@ var EmptyRequiredValueError = class extends ValidationError {
   }
 };
 
-// ../env-graph/src/lib/simple-queue.ts
-var SimpleQueue = class {
-  static {
-    __name(this, "SimpleQueue");
-  }
-  queue = [];
-  processing = false;
-  /** Add a task to the queue and return a promise that resolves when the task is complete */
-  async enqueue(task) {
-    return new Promise((resolve, reject) => {
-      this.queue.push(async () => {
-        try {
-          const result = await task();
-          resolve(result);
-        } catch (err) {
-          reject(err);
-        }
-      });
-      this.processQueue();
-    });
-  }
-  async processQueue() {
-    if (this.processing || this.queue.length === 0) {
-      return;
-    }
-    this.processing = true;
-    const task = this.queue.shift();
-    if (task) {
-      try {
-        await task();
-      } finally {
-        this.processing = false;
-        this.processQueue();
-      }
-    }
-  }
-};
-
-// ../env-graph/src/lib/resolver.ts
-var execAsync = promisify(exec);
-var Resolver = class {
-  constructor(fnArgs) {
-    this.fnArgs = fnArgs;
-  }
-  static {
-    __name(this, "Resolver");
-  }
-  static fnName;
-  inferredType;
-  _schemaErrors = [];
-  _depsObj = {};
-  get childResolvers() {
-    return this.fnArgs.flatMap((r) => my_dash_default.isPlainObject(r) ? my_dash_default.values(r) : r);
-  }
-  get schemaErrors() {
-    return [
-      ...this._schemaErrors,
-      ...this.childResolvers.flatMap((r) => r.schemaErrors)
-    ];
-  }
-  get depsObj() {
-    const mergedDepsObj = { ...this._depsObj };
-    this.childResolvers.forEach((r) => Object.assign(mergedDepsObj, r.depsObj));
-    return mergedDepsObj;
-  }
-  get deps() {
-    return Object.keys(this.depsObj);
-  }
-  configItem;
-  async process(configItem) {
-    this.configItem = configItem;
-    try {
-      await this._process(configItem);
-    } catch (error) {
-      if (error instanceof SchemaError) {
-        this._schemaErrors.push(error);
-      } else if (error instanceof Error) {
-        this._schemaErrors.push(new SchemaError(error));
-      } else {
-        throw new Error(`Non-error thrown while processing resolver - ${error}`);
-      }
-    }
-    this.childResolvers.forEach((r) => r.process(configItem));
-  }
-  // meant to be used by subclass _process methods
-  addDep(key) {
-    this._depsObj[key] = true;
-    if (!this.configItem) throw new Error("expected configItem to be set");
-    if (!this.configItem.envGraph.configSchema[key]) {
-      this._schemaErrors.push(new SchemaError(`Unknown referenced key: ${key}`));
-    }
-  }
-  async resolve() {
-    const resolvedValue = await this._resolve();
-    return resolvedValue;
-  }
-  // meant to be used by subclass _resolve methods
-  getDepValue(key) {
-    const depItem = this.configItem?.envGraph.configSchema[key];
-    if (!depItem) throw new Error(`Expected to find item - ${key}`);
-    return depItem.resolvedValue;
-  }
-};
-var StaticValueResolver = class extends Resolver {
-  constructor(staticValue) {
-    super([]);
-    this.staticValue = staticValue;
-    if (staticValue !== void 0) {
-      this.inferredType = typeof staticValue;
-    }
+// ../env-graph/src/lib/data-types.ts
+var EnvGraphDataType = class {
+  constructor(def, factory) {
+    this.def = def;
+    this.factory = factory;
   }
   static {
-    __name(this, "StaticValueResolver");
-  }
-  label = "static";
-  icon = "bi:dash";
-  async _resolve() {
-    return this.staticValue;
+    __name(this, "EnvGraphDataType");
   }
-  async _process() {
+  get name() {
+    return this.def.name;
   }
-};
-var ErrorResolver = class extends Resolver {
-  static {
-    __name(this, "ErrorResolver");
+  get icon() {
+    return this.def.icon;
   }
-  constructor(err) {
-    super([]);
-    this._schemaErrors.push(err);
+  /** @internal */
+  get _rawDef() {
+    return this.def;
   }
-  label = "error";
-  icon = "bi:dash";
-  async _resolve() {
-    return void 0;
+  coerce(val) {
+    return this.def.coerce ? this.def.coerce(val) : val;
   }
-  async _process() {
+  validate(val) {
+    return this.def.validate ? this.def.validate(val) : true;
   }
 };
-var ConcatResolver = class extends Resolver {
-  static {
-    __name(this, "ConcatResolver");
-  }
-  static fnName = "concat";
-  label = "concat";
-  icon = "material-symbols:join";
-  inferredType = "string";
-  async _process() {
-    if (this.fnArgs.some((arg) => my_dash_default.isPlainObject(arg))) {
-      throw new SchemaError("concat() does not support key-value arguments");
+function createEnvGraphDataType(dataTypeDef) {
+  const typeFactoryFn = /* @__PURE__ */ __name((...usageOpts) => {
+    return new EnvGraphDataType(
+      my_dash_default.isFunction(dataTypeDef) ? dataTypeDef(...usageOpts) : dataTypeDef,
+      typeFactoryFn
+    );
+  }, "typeFactoryFn");
+  typeFactoryFn._isEnvGraphDataTypeFactory = true;
+  const exampleInstance = typeFactoryFn(...[]);
+  typeFactoryFn.dataTypeName = exampleInstance.name;
+  return typeFactoryFn;
+}
+__name(createEnvGraphDataType, "createEnvGraphDataType");
+function coerceToString(rawVal) {
+  if (rawVal === void 0 || rawVal === null) return "";
+  return my_dash_default.isString(rawVal) ? rawVal : String(rawVal);
+}
+__name(coerceToString, "coerceToString");
+function coerceToNumber(rawVal) {
+  let numVal;
+  if (my_dash_default.isString(rawVal)) {
+    const parsed = parseFloat(rawVal);
+    if (my_dash_default.isNan(parsed) || parsed === Infinity || parsed === -Infinity) {
+      throw new CoercionError("Unable to coerce string to number");
     }
-    if (this.fnArgs.length < 2) {
-      throw new SchemaError("concat() expects at least two arguments");
+    numVal = parsed;
+  } else if (my_dash_default.isNumber(rawVal)) {
+    if (numVal === Infinity || numVal === -Infinity) {
+      throw new CoercionError("Inifinity is not a valid number");
     }
+    numVal = rawVal;
+  } else {
+    throw new CoercionError(`Cannot convert ${rawVal} to number`);
   }
-  async _resolve() {
-    const resolvedValues = [];
-    for (const arg of this.fnArgs) {
-      if (my_dash_default.isPlainObject(arg)) {
-        throw new Error("concat() does not support key-value arguments");
+  return numVal;
+}
+__name(coerceToNumber, "coerceToNumber");
+var StringDataType = createEnvGraphDataType(
+  (settings) => ({
+    name: "string",
+    icon: "carbon:string-text",
+    coerce: /* @__PURE__ */ __name((rawVal) => {
+      let val = coerceToString(rawVal);
+      if (settings?.toUpperCase) val = val.toUpperCase();
+      if (settings?.toLowerCase) val = val.toLowerCase();
+      return val;
+    }, "coerce"),
+    validate: /* @__PURE__ */ __name((val) => {
+      const errors = [];
+      if (settings?.minLength !== void 0 && val.length < settings.minLength) {
+        errors.push(new ValidationError(`Length must be more than ${settings.minLength}`));
       }
-      const resolvedChildValue = await arg.resolve();
-      resolvedValues.push(String(resolvedChildValue ?? ""));
-    }
-    return resolvedValues.join("");
-  }
-};
-var FallbackResolver = class extends Resolver {
-  static {
-    __name(this, "FallbackResolver");
-  }
-  static fnName = "fallback";
-  label = "fallback";
-  icon = "memory:table-top-stairs-up";
-  async _process() {
-    if (this.fnArgs.some((arg) => my_dash_default.isPlainObject(arg))) {
-      throw new SchemaError("fallback() does not support key-value arguments");
-    }
-    if (this.fnArgs.length < 2) {
-      throw new SchemaError("fallback() expects at least two arguments");
-    }
-  }
-  async _resolve() {
-    for (const arg of this.fnArgs) {
-      if (my_dash_default.isPlainObject(arg)) throw new Error("fallback() does not support key-value arguments");
-      const resolvedChildValue = await arg.resolve();
-      if (resolvedChildValue !== void 0 && resolvedChildValue !== "") {
-        return resolvedChildValue;
+      if (settings?.maxLength !== void 0 && val.length > settings.maxLength) {
+        errors.push(new ValidationError(`Length must be less than ${settings.maxLength}`));
       }
-    }
-  }
-};
-var ExecResolver = class _ExecResolver extends Resolver {
-  static {
-    __name(this, "ExecResolver");
-  }
-  static fnName = "exec";
-  label = "exec";
-  icon = "iconoir:terminal";
-  async _process() {
-    if (this.fnArgs.length !== 1) {
-      throw new SchemaError("exec() expects a single child arg");
-    }
-    if (this.fnArgs.some((arg) => my_dash_default.isPlainObject(arg))) {
-      throw new SchemaError("exec() does not support key-value arguments");
-    }
-  }
-  static execQueue = new SimpleQueue();
-  async _resolve() {
-    if (my_dash_default.isPlainObject(this.fnArgs[0])) throw new Error("exec() does not support key-value arguments");
-    const commandStr = await this.fnArgs[0].resolve();
-    if (typeof commandStr !== "string") {
-      throw new ResolutionError("exec() expects a string child arg");
-    }
-    try {
-      const { stdout, stderr } = await _ExecResolver.execQueue.enqueue(() => execAsync(commandStr));
-      return stdout.replace(/\n$/, "");
-    } catch (err) {
-      console.log("exec() failed", err);
-      throw new ResolutionError(`exec() command failed: ${commandStr}`);
-    }
-  }
-};
-var RefResolver = class extends Resolver {
-  static {
-    __name(this, "RefResolver");
-  }
-  static fnName = "ref";
-  label = "ref";
-  icon = "mdi-light:content-duplicate";
-  refKey;
-  async _process() {
-    if (this.fnArgs.length !== 1) {
-      throw new SchemaError("ref() expects a single child arg");
-    }
-    if (!(this.fnArgs[0] instanceof StaticValueResolver)) {
-      throw new SchemaError("ref() expects a single static value passed in");
-    }
-    const keyName = this.fnArgs[0].staticValue;
-    if (typeof keyName !== "string") {
-      throw new SchemaError("ref() expects a string keyname passed in");
-    }
-    this.refKey = keyName;
-    this.addDep(keyName);
-  }
-  async _resolve() {
-    if (!this.refKey) throw new Error("expected refKey to be set");
-    return this.getDepValue(this.refKey);
-  }
-};
-var RegexResolver = class extends Resolver {
-  static {
-    __name(this, "RegexResolver");
-  }
-  static fnName = "regex";
-  label = "regex";
-  icon = "mdi:regex";
-  regex;
-  async _process() {
-    if (this.fnArgs.length !== 1) {
-      throw new SchemaError("regex() expects a single child arg");
-    }
-    if (!(this.fnArgs[0] instanceof StaticValueResolver)) {
-      throw new SchemaError("regex() expects a single static value passed in");
-    }
-    const regexStr = this.fnArgs[0].staticValue;
-    if (typeof regexStr !== "string") {
-      throw new SchemaError("regex() expects a string");
-    }
-    this.regex = new RegExp(regexStr);
-  }
-  async _resolve() {
-    if (!this.regex) throw new Error("expected regex to be set");
-    return this.regex;
-  }
-};
-var RemapResolver = class extends Resolver {
-  static {
-    __name(this, "RemapResolver");
-  }
-  static fnName = "remap";
-  label = "remap";
-  icon = "codicon:replace";
-  remappings;
-  async _process() {
-    if (my_dash_default.isPlainObject(this.fnArgs[0])) {
-      throw new SchemaError("remap() expects the first arg to be the value to remap");
-    }
-    if (!my_dash_default.isPlainObject(this.fnArgs[1])) {
-      throw new SchemaError("remap() expects the all args after the first to be key-value pairs of remappings");
-    }
-    if (this.fnArgs.length !== 2) {
-      throw new SchemaError("remap() should not have any additional non key-value args after remappings");
-    }
-    this.remappings = this.fnArgs[1];
-  }
-  async _resolve() {
-    if (my_dash_default.isPlainObject(this.fnArgs[0])) {
-      throw new SchemaError("remap() expects the first arg to be the value to remap");
-    }
-    if (!my_dash_default.isPlainObject(this.fnArgs[1])) {
-      throw new SchemaError("remap() expects the all args after the first to be key-value pairs of remappings");
-    }
-    const originalValue = await this.fnArgs[0].resolve();
-    if (!this.remappings) throw new Error("expected remappings to be set");
-    for (const [remappedVal, matchValResolver] of Object.entries(this.remappings)) {
-      const matchVal = await matchValResolver.resolve();
-      if (matchVal instanceof RegExp && originalValue !== void 0) {
-        if (matchVal.test(String(originalValue))) return remappedVal;
-      } else {
-        if (matchVal === originalValue) return remappedVal;
+      if (settings?.isLength !== void 0 && val.length !== settings.isLength) {
+        errors.push(new ValidationError(`Length must be exactly ${settings.isLength}`));
+      }
+      if (settings?.startsWith && !val.startsWith(settings.startsWith)) {
+        errors.push(new ValidationError(`Value must start with "${settings.startsWith}"`));
+      }
+      if (settings?.endsWith && !val.endsWith(settings.endsWith)) {
+        errors.push(new ValidationError(`Value must start with "${settings.endsWith}"`));
+      }
+      if (settings?.matches) {
+        const regex = my_dash_default.isString(settings.matches) ? new RegExp(settings.matches) : settings.matches;
+        const matches = val.match(regex);
+        if (!matches) {
+          errors.push(new ValidationError(`Value must match regex "${settings.matches}"`));
+        }
+      }
+      return errors.length ? errors : true;
+    }, "validate")
+  })
+);
+var NumberDataType = createEnvGraphDataType(
+  (settings) => ({
+    name: "number",
+    icon: "carbon:string-integer",
+    coerce(rawVal) {
+      let numVal = coerceToNumber(rawVal);
+      if (settings?.coerceToMinMaxRange) {
+        if (settings?.min !== void 0) numVal = Math.max(settings?.min, numVal);
+        if (settings?.max !== void 0) numVal = Math.min(settings?.max, numVal);
+      }
+      if (settings?.isInt === true || settings?.precision === 0) {
+        numVal = Math.round(numVal);
+      } else if (settings?.precision) {
+        const p = 10 ** settings.precision;
+        numVal = Math.round(numVal * p) / p;
+      }
+      return numVal;
+    },
+    validate(val) {
+      const errors = [];
+      if (settings?.min !== void 0 && val < settings?.min) {
+        errors.push(new ValidationError(`Min value is ${settings?.min}`));
+      }
+      if (settings?.max !== void 0 && val > settings?.max) {
+        errors.push(new ValidationError(`Max value is ${settings?.max}`));
       }
+      if (settings?.isDivisibleBy !== void 0 && val % settings.isDivisibleBy !== 0) {
+        errors.push(new ValidationError(`Value must be divisible by ${settings?.isDivisibleBy}`));
+      }
+      return errors.length ? errors : true;
+    }
+  })
+);
+var BooleanDataType = createEnvGraphDataType({
+  name: "boolean",
+  icon: "carbon:boolean",
+  // probably want allow some settings
+  // - more strict about coercion or adding additional true/false values
+  // - coercing to other values - like 0,1
+  coerce(val) {
+    if (my_dash_default.isBoolean(val)) {
+      return val;
+    } else if (my_dash_default.isString(val)) {
+      const cleanVal = val.toLowerCase().trim();
+      if (["t", "true", "yes", "on", "1"].includes(cleanVal)) return true;
+      if (["f", "false", "no", "off", "0"].includes(cleanVal)) return false;
+      throw new CoercionError("Unable to coerce string value to boolean");
+    } else if (my_dash_default.isNumber(val)) {
+      if (val === 0) return false;
+      if (val === 1) return true;
+      throw new CoercionError("Unable to coerce number value to boolean (only 0 or 1 is valid)");
+    } else {
+      throw new CoercionError("Unable to coerce value to boolean");
     }
-    return originalValue;
-  }
-};
-var BaseResolvers = [
-  ConcatResolver,
-  FallbackResolver,
-  RefResolver,
-  ExecResolver,
-  RemapResolver,
-  RegexResolver
-];
-
-// ../env-graph/src/lib/data-source.ts
-var DATA_SOURCE_TYPES = Object.freeze({
-  schema: {
-    fileSuffixes: ["schema"],
-    precedence: 0
-  },
-  example: {
-    fileSuffixes: ["sample", "example"],
-    precedence: 1
-  },
-  defaults: {
-    fileSuffixes: ["default", "defaults"],
-    precedence: 2
-  },
-  values: {
-    fileSuffixes: [],
-    precedence: 3
   },
-  overrides: {
-    fileSuffixes: ["local", "override"],
-    precedence: 4
+  // TODO: add settings to be more strict, or to allow other values to coerce to true/false
+  validate(val) {
+    if (my_dash_default.isBoolean(val)) return true;
+    return new ValidationError("Value must be `true` or `false`");
   }
 });
-var EnvGraphDataSource = class {
-  static {
-    __name(this, "EnvGraphDataSource");
-  }
-  static DATA_SOURCE_TYPES = DATA_SOURCE_TYPES;
-  // reference back to the graph
-  graph;
-  type = "values";
-  applyForEnv;
-  disabled = false;
-  ignoreNewDefs = false;
-  /** an error encountered while loading/parsing the data source */
-  loadingError;
-  get isValid() {
-    return !this.loadingError;
-  }
-  configItemDefs = {};
-  decorators = {};
-  getStaticValues() {
-    const obj = {};
-    for (const [key, def] of Object.entries(this.configItemDefs)) {
-      if (def.resolver instanceof StaticValueResolver) {
-        obj[key] = String(def.resolver.staticValue ?? "");
+var UrlDataType = createEnvGraphDataType(
+  (settings) => ({
+    name: "url",
+    icon: "carbon:url",
+    coerce(rawVal) {
+      const val = coerceToString(rawVal);
+      if (settings?.prependHttps && !val.startsWith("https://")) return `https://${val}`;
+      return val;
+    },
+    validate(val) {
+      const url = new URL(val);
+      if (settings?.allowedDomains && !settings.allowedDomains.includes(url.host.toLowerCase())) {
+        return new ValidationError(`Domain (${url.host}) is not in allowed list: ${settings.allowedDomains.join(",")}`);
       }
+      return true;
     }
-    return obj;
-  }
-};
-var ProcessEnvDataSource = class _ProcessEnvDataSource extends EnvGraphDataSource {
-  static {
-    __name(this, "ProcessEnvDataSource");
-  }
-  type = "overrides";
-  typeLabel = "process";
-  label = "process.env";
-  ignoreNewDefs = true;
-  static processEnvValues;
-  // ? do we want to set decorator values from env vars here? -- ex: _ENV_FLAG_KEY
-  // depends if we want those to work only within process.env
-  constructor() {
-    super();
-    if (!_ProcessEnvDataSource.processEnvValues) {
-      _ProcessEnvDataSource.processEnvValues = {};
-      for (const itemKey of Object.keys(process.env)) {
-        _ProcessEnvDataSource.processEnvValues[itemKey] = process.env[itemKey];
+  })
+);
+var SimpleObjectDataType = createEnvGraphDataType({
+  name: "simple-object",
+  icon: "tabler:code-dots",
+  // curly brackets with nothing inside
+  coerce(val) {
+    if (my_dash_default.isPlainObject(val)) return val;
+    if (my_dash_default.isString(val)) {
+      try {
+        const parsedObj = JSON.parse(val);
+        if (my_dash_default.isPlainObject(parsedObj)) return parsedObj;
+        return new CoercionError("Unable to coerce JSON parsed string to object");
+      } catch (err) {
+        return new CoercionError("Error parsing JSON string while coercing string to object");
       }
     }
-    for (const itemKey of Object.keys(_ProcessEnvDataSource.processEnvValues)) {
-      this.configItemDefs[itemKey] = {
-        resolver: new StaticValueResolver(_ProcessEnvDataSource.processEnvValues[itemKey])
-      };
-    }
-  }
-};
-var EnvSourceParseError = class extends Error {
-  constructor(message, location) {
-    super(message);
-    this.location = location;
-  }
-  static {
-    __name(this, "EnvSourceParseError");
-  }
-};
-var FileBasedDataSource = class extends EnvGraphDataSource {
-  static {
-    __name(this, "FileBasedDataSource");
-  }
-  isGitIgnored;
-  fullPath;
-  fileName;
-  rawContents;
-  get typeLabel() {
-    return this.constructor.format;
-  }
-  get label() {
-    return this.fileName;
-  }
-  static format = "unknown";
-  // no abstract static
-  static validFileExtensions = [];
-  get validFileExtensions() {
-    return this.constructor.validFileExtensions;
-  }
-  constructor(fullPath, opts) {
-    super();
-    this.fullPath = fullPath;
-    this.fileName = path.basename(fullPath);
-    if (opts?.overrideContents) {
-      this.rawContents = opts.overrideContents;
-      this.isGitIgnored = opts.overrideGitIgnored;
-    }
-    if (!this.fileName.startsWith(".env")) {
-      throw new Error('file name must start with ".env"');
+    return new CoercionError("Cannot coerce value to object");
+  },
+  validate(val) {
+    if (my_dash_default.isPlainObject(val)) return true;
+    return new ValidationError("Value must be an object");
+  }
+});
+var EnumDataType = createEnvGraphDataType(
+  (...enumOptions) => ({
+    name: "enum",
+    icon: "material-symbols-light:category",
+    // a few shapes... not sure about this one
+    coerce(val) {
+      if (my_dash_default.isString(val) || my_dash_default.isNumber(val) || my_dash_default.isBoolean(val)) return val;
+      return new CoercionError("Value must be a string, number, or boolean");
+    },
+    validate(val) {
+      const possibleValues = enumOptions || [];
+      if (!possibleValues.includes(val)) {
+        throw new ValidationError("Current value is not in list of possible values", {
+          tip: `Possible values are: "${possibleValues.join('", "')}"`
+        });
+      }
+    },
+    _rawEnumOptions: enumOptions
+  })
+);
+var EMAIL_REGEX = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+var EmailDataType = createEnvGraphDataType(
+  (settings) => ({
+    name: "email",
+    icon: "iconoir:at-sign",
+    typeDescription: "standard email address",
+    coerce(rawVal) {
+      let val = coerceToString(rawVal);
+      if (settings?.normalize) val = val.toLowerCase();
+      return val;
+    },
+    validate(val) {
+      const result = EMAIL_REGEX.test(val);
+      if (result) return true;
+      return new ValidationError("Value must be a valid email address");
     }
-    const fileNameParts = this.fileName.substring(1).split(".");
-    const maybeExtension = fileNameParts[fileNameParts.length - 1];
-    if (this.validFileExtensions.includes(maybeExtension)) {
-      fileNameParts.pop();
+  })
+);
+var IP_V4_ADDRESS_REGEX = /^(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}$/;
+var IP_V6_ADDRESS_REGEX = /^(?:(?:[a-fA-F\d]{1,4}:){7}(?:[a-fA-F\d]{1,4}|:)|(?:[a-fA-F\d]{1,4}:){6}(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|:[a-fA-F\d]{1,4}|:)|(?:[a-fA-F\d]{1,4}:){5}(?::(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,2}|:)|(?:[a-fA-F\d]{1,4}:){4}(?:(?::[a-fA-F\d]{1,4}){0,1}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,3}|:)|(?:[a-fA-F\d]{1,4}:){3}(?:(?::[a-fA-F\d]{1,4}){0,2}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,4}|:)|(?:[a-fA-F\d]{1,4}:){2}(?:(?::[a-fA-F\d]{1,4}){0,3}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,5}|:)|(?:[a-fA-F\d]{1,4}:){1}(?:(?::[a-fA-F\d]{1,4}){0,4}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,6}|:)|(?::(?:(?::[a-fA-F\d]{1,4}){0,5}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,7}|:)))(?:%[0-9a-zA-Z]{1,})?$/;
+var ipAddressDataType = createEnvGraphDataType(
+  (settings) => ({
+    name: "ip",
+    icon: "iconoir:ip-address-tag",
+    typeDescription: "ip v4 or v6 address",
+    coerce(rawVal) {
+      let val = coerceToString(rawVal);
+      if (settings?.normalize) val = val.toLowerCase();
+      return val;
+    },
+    validate(val) {
+      const regex = settings?.version === 6 ? IP_V6_ADDRESS_REGEX : IP_V4_ADDRESS_REGEX;
+      const result = regex.test(val);
+      if (result) return true;
+      return new ValidationError("Value must be a valid IP address");
     }
-    const maybeFileType = fileNameParts[fileNameParts.length - 1];
-    for (const [possibleSourceType, possibleSourceSpec] of Object.entries(DATA_SOURCE_TYPES)) {
-      if (possibleSourceSpec.fileSuffixes.includes(maybeFileType)) {
-        this.type = possibleSourceType;
-        break;
+  })
+);
+var PortDataType = createEnvGraphDataType(
+  (settings) => ({
+    name: "port",
+    icon: "material-symbols:captive-portal",
+    //! globe with arrow - not sure about this one
+    typeDescription: "valid port number between 0 and 65535",
+    coerce(rawVal) {
+      if (my_dash_default.isString(rawVal)) {
+        if (rawVal.includes(".")) throw new CoercionError("Port number must be an integer");
+        if (rawVal.includes("e")) throw new CoercionError("Port number should be an integer, not in exponential notation");
+      }
+      return coerceToNumber(rawVal);
+    },
+    validate(val) {
+      if (settings?.min !== void 0 && val < settings?.min) {
+        return new ValidationError(`Min value is ${settings?.min}`);
+      }
+      if (settings?.max !== void 0 && val > settings?.max) {
+        return new ValidationError(`Max value is ${settings?.max}`);
+      }
+      if (val < 0 || val > 65535) {
+        return new ValidationError("Value must be a valid port number (0-65535)");
       }
+      return true;
     }
-    if (this.type !== "values") fileNameParts.pop();
-    if (fileNameParts.length > 2) {
-      throw Error(`Unsure how to interpret filename - ${this.fileName}`);
-    } else if (fileNameParts.length === 2) {
-      this.applyForEnv = fileNameParts[1];
-      if (this.applyForEnv === "dev") this.applyForEnv = "development";
-      if (this.applyForEnv === "stage") this.applyForEnv = "staging";
-      if (this.applyForEnv === "prod") this.applyForEnv = "production";
+  })
+);
+var SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+var SemverDataType = createEnvGraphDataType(
+  (settings) => ({
+    name: "semver",
+    icon: "simple-icons:semver",
+    typeDescription: "semantic version string",
+    validate(val) {
+      const result = SEMVER_REGEX.test(val);
+      if (result) return true;
+      return new ValidationError("Value must be a valid semantic version string");
     }
+  })
+);
+var ISO_DATE_REGEX = /^(?:[+-]?\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24:?00)(?:[.,]\d+(?!:))?)?(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[zZ]|(?:[+-])(?:[01]\d|2[0-3]):?(?:[0-5]\d)?)?)?)?$/;
+var IsoDateDataType = createEnvGraphDataType({
+  name: "isoDate",
+  icon: "formkit:datetime",
+  typeDescription: "ISO 8601 date string with optional time and milliseconds",
+  validate(val) {
+    const result = ISO_DATE_REGEX.test(val);
+    if (result) return true;
+    return new ValidationError("Value must be a valid ISO 8601 date string");
   }
-  // no async constructors... :(
-  async finishInit() {
-    if (!this.rawContents) {
-      this.isGitIgnored = await checkIsFileGitIgnored(this.fullPath);
-      this.rawContents = await fs.readFile(this.fullPath, "utf8");
-    }
-    await this._parseContents();
+});
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var UuidDataType = createEnvGraphDataType({
+  name: "uuid",
+  icon: "mdi:identifier",
+  typeDescription: "UUID string V1-V5 per RFC4122, including NIL",
+  validate(val) {
+    const result = UUID_REGEX.test(val);
+    if (result) return true;
+    return new ValidationError("Value must be a valid UUID string");
+  }
+});
+var MD5_REGEX = /^[a-f0-9]{32}$/;
+var Md5DataType = createEnvGraphDataType({
+  name: "md5",
+  typeDescription: "MD5 hash string",
+  validate(val) {
+    const result = MD5_REGEX.test(val);
+    if (result) return true;
+    return new ValidationError("Value must be a valid MD5 hash string");
   }
+});
+var BaseDataTypes = {
+  string: StringDataType,
+  number: NumberDataType,
+  boolean: BooleanDataType,
+  simpleObject: SimpleObjectDataType,
+  enum: EnumDataType,
+  email: EmailDataType,
+  url: UrlDataType,
+  ipAddress: ipAddressDataType,
+  port: PortDataType,
+  semver: SemverDataType,
+  isoDate: IsoDateDataType,
+  uuid: UuidDataType,
+  md5: Md5DataType
 };
-var DotEnvFileDataSource = class extends FileBasedDataSource {
+
+// ../env-graph/src/lib/simple-queue.ts
+var SimpleQueue = class {
   static {
-    __name(this, "DotEnvFileDataSource");
+    __name(this, "SimpleQueue");
   }
-  static format = ".env";
-  static validFileExtensions = [];
-  // no extension for dotenv files!
-  parsedFile;
-  convertParserValueToResolvers(value) {
-    if (!this.graph) throw new Error("expected graph to be set");
-    if (value === void 0) {
-      return new StaticValueResolver(void 0);
-    } else if (value instanceof ParsedEnvSpecStaticValue) {
-      return new StaticValueResolver(value.unescapedValue);
-    } else if (value instanceof ParsedEnvSpecFunctionCall) {
-      const ResolverFnClass = this.graph.registeredResolverFunctions[value.name];
-      if (!ResolverFnClass) {
-        return new ErrorResolver(new SchemaError(`Unknown resolver function: ${value.name}()`));
-      }
-      const argsFromParser = value.data.args.values;
-      let keyValueArgs;
-      const argsAsResolversArray = [];
-      for (const arg of argsFromParser) {
-        if (arg instanceof ParsedEnvSpecKeyValuePair) {
-          keyValueArgs ??= {};
-          keyValueArgs[arg.key] = this.convertParserValueToResolvers(arg.value);
-        } else {
-          if (keyValueArgs) {
-            return new ErrorResolver(new SchemaError("After switching to key-value function args, cannot switch back"));
-          }
-          argsAsResolversArray.push(this.convertParserValueToResolvers(arg));
+  queue = [];
+  processing = false;
+  /** Add a task to the queue and return a promise that resolves when the task is complete */
+  async enqueue(task) {
+    return new Promise((resolve, reject) => {
+      this.queue.push(async () => {
+        try {
+          const result = await task();
+          resolve(result);
+        } catch (err) {
+          reject(err);
         }
-      }
-      if (keyValueArgs) argsAsResolversArray.push(keyValueArgs);
-      return new ResolverFnClass(argsAsResolversArray);
-    } else {
-      throw new Error("Unknown value type");
-    }
+      });
+      this.processQueue();
+    });
   }
-  async _parseContents() {
-    const rawContents = this.rawContents;
-    this.parsedFile = await tryCatch(
-      () => parseEnvSpecDotEnvFile(rawContents),
-      (error) => {
-        this.loadingError = new EnvSourceParseError(error.message, {
-          path: this.fullPath,
-          lineNumber: error.location.start.line,
-          colNumber: error.location.start.column,
-          lineStr: rawContents.split("\n")[error.location.start.line - 1]
-        });
-        this.loadingError.cause = error;
+  async processQueue() {
+    if (this.processing || this.queue.length === 0) {
+      return;
+    }
+    this.processing = true;
+    const task = this.queue.shift();
+    if (task) {
+      try {
+        await task();
+      } finally {
+        this.processing = false;
+        this.processQueue();
       }
-    );
-    if (this.loadingError) return;
-    if (!this.parsedFile) throw new Error("Failed to parse .env file");
-    this.decorators = this.parsedFile.decoratorsObject;
-    if (!this.graph) throw new Error("expected graph to be set");
-    for (const item of this.parsedFile.configItems) {
-      item.processExpansion();
-      this.configItemDefs[item.key] = {
-        resolver: this.convertParserValueToResolvers(item.expandedValue),
-        description: item.description,
-        decorators: item.decoratorsObject
-      };
     }
   }
 };
-var ConfigItem = class {
-  constructor(envGraph, key) {
-    this.envGraph = envGraph;
-    this.key = key;
+
+// ../env-graph/src/lib/resolver.ts
+var execAsync = promisify(exec);
+var Resolver = class {
+  constructor(fnArgs) {
+    this.fnArgs = fnArgs;
   }
   static {
-    __name(this, "ConfigItem");
-  }
-  defs = [];
-  addDef(itemDef, source) {
-    this.defs.unshift({ itemDef, source });
+    __name(this, "Resolver");
   }
-  get description() {
-    for (const def of this.defs) {
-      if (def.itemDef.description) return def.itemDef.description;
-    }
+  static fnName;
+  inferredType;
+  _schemaErrors = [];
+  _depsObj = {};
+  get childResolvers() {
+    return this.fnArgs.flatMap((r) => my_dash_default.isPlainObject(r) ? my_dash_default.values(r) : r);
   }
-  get icon() {
-    const explicitIcon = this.getDecoratorValueString("icon");
-    if (explicitIcon) return explicitIcon;
-    return this.dataType?.icon;
+  get schemaErrors() {
+    return [
+      ...this._schemaErrors,
+      ...this.childResolvers.flatMap((r) => r.schemaErrors)
+    ];
   }
-  get docsLinks() {
-    const links = [];
-    const docsUrl = this.getDecoratorValueString("docsUrl");
-    if (docsUrl) links.push({ url: docsUrl });
-    return links;
+  get depsObj() {
+    const mergedDepsObj = { ...this._depsObj };
+    this.childResolvers.forEach((r) => Object.assign(mergedDepsObj, r.depsObj));
+    return mergedDepsObj;
   }
-  get valueResolver() {
-    for (const def of this.defs) {
-      if (def.itemDef.resolver) return def.itemDef.resolver;
-    }
+  get deps() {
+    return Object.keys(this.depsObj);
   }
-  getDecorator(decoratorName) {
-    for (const def of this.defs) {
-      const defDecorators = def.itemDef.decorators || {};
-      if (decoratorName in defDecorators) {
-        return defDecorators[decoratorName];
+  configItem;
+  async process(configItem) {
+    this.configItem = configItem;
+    try {
+      await this._process(configItem);
+    } catch (error) {
+      if (error instanceof SchemaError) {
+        this._schemaErrors.push(error);
+      } else if (error instanceof Error) {
+        this._schemaErrors.push(new SchemaError(error));
+      } else {
+        throw new Error(`Non-error thrown while processing resolver - ${error}`);
       }
     }
+    this.childResolvers.forEach((r) => r.process(configItem));
   }
-  getDecoratorValueRaw(decoratorName) {
-    for (const def of this.defs) {
-      const defDecorators = def.itemDef.decorators || {};
-      if (decoratorName in defDecorators) {
-        return defDecorators[decoratorName].value;
-      }
+  // meant to be used by subclass _process methods
+  addDep(key) {
+    this._depsObj[key] = true;
+    if (!this.configItem) throw new Error("expected configItem to be set");
+    if (!this.configItem.envGraph.configSchema[key]) {
+      this._schemaErrors.push(new SchemaError(`Unknown referenced key: ${key}`));
     }
   }
-  getDecoratorValueString(decoratorName) {
-    const dec = this.getDecoratorValueRaw(decoratorName);
-    if (dec instanceof ParsedEnvSpecStaticValue) return String(dec.value);
+  async resolve() {
+    const resolvedValue = await this._resolve();
+    return resolvedValue;
   }
-  dataType;
-  schemaErrors = [];
-  get resolverSchemaErrors() {
-    return this.valueResolver?.schemaErrors || [];
+  // meant to be used by subclass _resolve methods
+  getDepValue(key) {
+    const depItem = this.configItem?.envGraph.configSchema[key];
+    if (!depItem) throw new Error(`Expected to find item - ${key}`);
+    return depItem.resolvedValue;
   }
-  async process() {
-    const finalOverrideDef = this.envGraph.finalOverridesDataSource?.configItemDefs[this.key];
-    if (finalOverrideDef) {
-      this.defs.unshift({ itemDef: finalOverrideDef, source: this.envGraph.finalOverridesDataSource });
-    }
-    for (const def of this.defs) {
-      await def.itemDef.resolver?.process(this);
-    }
-    const typeDecoratorValue = this.getDecoratorValueRaw("type");
-    let dataTypeName;
-    let dataTypeArgs;
-    if (typeDecoratorValue instanceof ParsedEnvSpecStaticValue) {
-      dataTypeName = typeDecoratorValue.value;
-    } else if (typeDecoratorValue instanceof ParsedEnvSpecFunctionCall) {
-      dataTypeName = typeDecoratorValue.name;
-      dataTypeArgs = typeDecoratorValue.simplifiedArgs;
-    }
-    if (!dataTypeName) {
-      if (this.valueResolver?.inferredType) {
-        dataTypeName = this.valueResolver.inferredType;
-      }
-    }
-    dataTypeName ||= "string";
-    dataTypeArgs ||= [];
-    if (!(dataTypeName in this.envGraph.dataTypesRegistry)) {
-      this.schemaErrors.push(new SchemaError(`unknown data type: ${dataTypeName}`));
-    } else {
-      const dataTypeFactory = this.envGraph.dataTypesRegistry[dataTypeName];
-      this.dataType = dataTypeFactory(...my_dash_default.isPlainObject(dataTypeArgs) ? [dataTypeArgs] : dataTypeArgs);
+};
+var StaticValueResolver = class extends Resolver {
+  constructor(staticValue) {
+    super([]);
+    this.staticValue = staticValue;
+    if (staticValue !== void 0) {
+      this.inferredType = typeof staticValue;
     }
   }
-  get isRequired() {
-    for (const def of this.defs) {
-      const defDecorators = def.itemDef.decorators || {};
-      if ("required" in defDecorators) {
-        const val = defDecorators.required.simplifiedValue;
-        if (typeof val === "boolean") return val;
-        if (typeof val === "string") return val === "true";
-        return Boolean(val);
-      }
-      if ("optional" in defDecorators) {
-        const val = defDecorators.optional.simplifiedValue;
-        if (typeof val === "boolean") return !val;
-        if (typeof val === "string") return val !== "true";
-        return !val;
-      }
-      if ("defaultRequired" in def.source.decorators) {
-        const val = def.source.decorators.defaultRequired.simplifiedValue;
-        if (val === "infer") {
-          if (def.source.type === "schema") {
-            const resolver = def.itemDef.resolver;
-            if (resolver instanceof StaticValueResolver) {
-              return resolver.staticValue !== void 0 && resolver.staticValue !== "";
-            } else {
-              return true;
-            }
-          } else {
-            continue;
-          }
-        }
-        return val;
-      }
-    }
-    return true;
+  static {
+    __name(this, "StaticValueResolver");
   }
-  get isSensitive() {
-    for (const def of this.defs) {
-      const defDecorators = def.itemDef.decorators || {};
-      if ("sensitive" in defDecorators) {
-        return defDecorators.sensitive.simplifiedValue;
-      } else if ("defaultSensitive" in def.source.decorators) {
-        const dec = def.source.decorators.defaultSensitive;
-        if (dec.value instanceof ParsedEnvSpecFunctionCall && dec.value.name === "inferFromPrefix") {
-          const args = dec.value.simplifiedArgs;
-          const prefix = Array.isArray(args) && args.length > 0 ? args[0] : void 0;
-          if (typeof prefix === "string" && this.key.startsWith(prefix)) {
-            return false;
-          }
-          return true;
-        }
-        return dec.simplifiedValue;
-      }
-    }
-    return true;
+  label = "static";
+  icon = "bi:dash";
+  async _resolve() {
+    return this.staticValue;
   }
-  get errors() {
-    return my_dash_default.compact([
-      ...this.schemaErrors || [],
-      ...this.resolverSchemaErrors || [],
-      this.resolutionError,
-      this.coercionError,
-      ...this.validationErrors || []
-    ]);
+  async _process() {
   }
-  get validationState() {
-    const errors = this.errors;
-    if (!errors.length) return "valid";
-    return my_dash_default.some(errors, (e) => !e.isWarning) ? "error" : "warn";
+};
+var ErrorResolver = class extends Resolver {
+  static {
+    __name(this, "ErrorResolver");
   }
-  /** resolved value _before coercion_ */
-  resolvedRawValue;
-  isResolved = false;
-  /** resolved value after coercion */
-  resolvedValue;
-  isValidated = false;
-  resolutionError;
-  coercionError;
-  validationErrors;
-  get isCoerced() {
-    return this.resolvedRawValue !== this.resolvedValue;
+  constructor(err) {
+    super([]);
+    this._schemaErrors.push(err);
   }
-  async resolve() {
-    if (this.schemaErrors.length) return;
-    if (this.resolverSchemaErrors.length) return;
-    if (!this.valueResolver) throw new Error("Expected a resolver to be set");
-    if (this.isResolved) {
-      return;
-    }
-    try {
-      this.resolvedRawValue = await this.valueResolver.resolve();
-    } catch (err) {
-      this.resolutionError = new ResolutionError(`error resolving value: ${err}`);
-      this.resolutionError.cause = err;
-    }
-    if (this.resolvedRawValue instanceof RegExp) {
-      this.resolutionError = new ResolutionError("regex() is meant to be used within function args, not as a final resolved value");
-    }
-    if (this.resolutionError) return;
-    this.isResolved = true;
-    if (this.resolvedRawValue === void 0 || this.resolvedRawValue === "") {
-      this.resolvedValue = this.resolvedRawValue;
-      if (this.isRequired) {
-        this.validationErrors = [new EmptyRequiredValueError(void 0)];
-      }
-      return;
+  label = "error";
+  icon = "bi:dash";
+  async _resolve() {
+    return void 0;
+  }
+  async _process() {
+  }
+};
+var ConcatResolver = class extends Resolver {
+  static {
+    __name(this, "ConcatResolver");
+  }
+  static fnName = "concat";
+  label = "concat";
+  icon = "material-symbols:join";
+  inferredType = "string";
+  async _process() {
+    if (this.fnArgs.some((arg) => my_dash_default.isPlainObject(arg))) {
+      throw new SchemaError("concat() does not support key-value arguments");
     }
-    if (!this.dataType) throw new Error("expected dataType to be set");
-    try {
-      const coerceResult = this.dataType.coerce(this.resolvedRawValue);
-      if (coerceResult instanceof Error) throw coerceResult;
-      this.resolvedValue = coerceResult;
-    } catch (err) {
-      if (err instanceof CoercionError) {
-        this.coercionError = err;
-        return;
-      } else if (err instanceof Error) {
-        this.coercionError = new CoercionError("Unexpected error coercing value");
-        this.coercionError.cause = err;
-      } else {
-        this.coercionError = new CoercionError(`Unexpected non-error throw during coerce - ${err}`);
-      }
-      return;
+    if (this.fnArgs.length < 2) {
+      throw new SchemaError("concat() expects at least two arguments");
     }
-    try {
-      const validateResult = this.dataType.validate(this.resolvedValue);
-      if (validateResult instanceof Error || my_dash_default.isArray(validateResult) && validateResult[0] instanceof Error) throw validateResult;
-      if (validateResult === false) {
-        throw new ValidationError("validation failed with `false` return value");
-      }
-      this.isValidated = true;
-    } catch (err) {
-      if (my_dash_default.isArray(err)) {
-        this.validationErrors = err;
-      } else if (err instanceof ValidationError) {
-        this.validationErrors = [err];
-      } else if (err instanceof Error) {
-        const validationError = new ValidationError("Unexpected error during validation");
-        validationError.cause = err;
-        console.log(err);
-        this.validationErrors = [validationError];
-      } else {
-        const validationError = new ValidationError(`Unexpected non-error thrown during validation - ${err}`);
-        validationError.cause = err;
-        this.validationErrors = [validationError];
+  }
+  async _resolve() {
+    const resolvedValues = [];
+    for (const arg of this.fnArgs) {
+      if (my_dash_default.isPlainObject(arg)) {
+        throw new Error("concat() does not support key-value arguments");
       }
-      return;
+      const resolvedChildValue = await arg.resolve();
+      resolvedValues.push(String(resolvedChildValue ?? ""));
     }
-  }
-  get isValid() {
-    return this.validationState === "valid";
+    return resolvedValues.join("");
   }
 };
-
-// ../env-graph/src/lib/data-types.ts
-var EnvGraphDataType = class {
-  constructor(def, factory) {
-    this.def = def;
-    this.factory = factory;
-  }
+var FallbackResolver = class extends Resolver {
   static {
-    __name(this, "EnvGraphDataType");
+    __name(this, "FallbackResolver");
   }
-  get name() {
-    return this.def.name;
+  static fnName = "fallback";
+  label = "fallback";
+  icon = "memory:table-top-stairs-up";
+  async _process() {
+    if (this.fnArgs.some((arg) => my_dash_default.isPlainObject(arg))) {
+      throw new SchemaError("fallback() does not support key-value arguments");
+    }
+    if (this.fnArgs.length < 2) {
+      throw new SchemaError("fallback() expects at least two arguments");
+    }
   }
-  get icon() {
-    return this.def.icon;
+  async _resolve() {
+    for (const arg of this.fnArgs) {
+      if (my_dash_default.isPlainObject(arg)) throw new Error("fallback() does not support key-value arguments");
+      const resolvedChildValue = await arg.resolve();
+      if (resolvedChildValue !== void 0 && resolvedChildValue !== "") {
+        return resolvedChildValue;
+      }
+    }
   }
-  /** @internal */
-  get _rawDef() {
-    return this.def;
+};
+var ExecResolver = class _ExecResolver extends Resolver {
+  static {
+    __name(this, "ExecResolver");
   }
-  coerce(val) {
-    return this.def.coerce ? this.def.coerce(val) : val;
+  static fnName = "exec";
+  label = "exec";
+  icon = "iconoir:terminal";
+  async _process() {
+    if (this.fnArgs.length !== 1) {
+      throw new SchemaError("exec() expects a single child arg");
+    }
+    if (this.fnArgs.some((arg) => my_dash_default.isPlainObject(arg))) {
+      throw new SchemaError("exec() does not support key-value arguments");
+    }
   }
-  validate(val) {
-    return this.def.validate ? this.def.validate(val) : true;
+  static execQueue = new SimpleQueue();
+  async _resolve() {
+    if (my_dash_default.isPlainObject(this.fnArgs[0])) throw new Error("exec() does not support key-value arguments");
+    const commandStr = await this.fnArgs[0].resolve();
+    if (typeof commandStr !== "string") {
+      throw new ResolutionError("exec() expects a string child arg");
+    }
+    try {
+      const { stdout, stderr } = await _ExecResolver.execQueue.enqueue(() => execAsync(commandStr));
+      return stdout.replace(/\n$/, "");
+    } catch (err) {
+      console.log("exec() failed", err);
+      throw new ResolutionError(`exec() command failed: ${commandStr}`);
+    }
   }
 };
-function createEnvGraphDataType(dataTypeDef) {
-  const typeFactoryFn = /* @__PURE__ */ __name((...usageOpts) => {
-    return new EnvGraphDataType(
-      my_dash_default.isFunction(dataTypeDef) ? dataTypeDef(...usageOpts) : dataTypeDef,
-      typeFactoryFn
-    );
-  }, "typeFactoryFn");
-  typeFactoryFn._isEnvGraphDataTypeFactory = true;
-  const exampleInstance = typeFactoryFn(...[]);
-  typeFactoryFn.dataTypeName = exampleInstance.name;
-  return typeFactoryFn;
-}
-__name(createEnvGraphDataType, "createEnvGraphDataType");
-function coerceToString(rawVal) {
-  if (rawVal === void 0 || rawVal === null) return "";
-  return my_dash_default.isString(rawVal) ? rawVal : String(rawVal);
-}
-__name(coerceToString, "coerceToString");
-function coerceToNumber(rawVal) {
-  let numVal;
-  if (my_dash_default.isString(rawVal)) {
-    const parsed = parseFloat(rawVal);
-    if (my_dash_default.isNan(parsed) || parsed === Infinity || parsed === -Infinity) {
-      throw new CoercionError("Unable to coerce string to number");
+var RefResolver = class extends Resolver {
+  static {
+    __name(this, "RefResolver");
+  }
+  static fnName = "ref";
+  label = "ref";
+  icon = "mdi-light:content-duplicate";
+  refKey;
+  async _process() {
+    if (this.fnArgs.length !== 1) {
+      throw new SchemaError("ref() expects a single child arg");
     }
-    numVal = parsed;
-  } else if (my_dash_default.isNumber(rawVal)) {
-    if (numVal === Infinity || numVal === -Infinity) {
-      throw new CoercionError("Inifinity is not a valid number");
+    if (!(this.fnArgs[0] instanceof StaticValueResolver)) {
+      throw new SchemaError("ref() expects a single static value passed in");
     }
-    numVal = rawVal;
-  } else {
-    throw new CoercionError(`Cannot convert ${rawVal} to number`);
+    const keyName = this.fnArgs[0].staticValue;
+    if (typeof keyName !== "string") {
+      throw new SchemaError("ref() expects a string keyname passed in");
+    }
+    this.refKey = keyName;
+    this.addDep(keyName);
   }
-  return numVal;
-}
-__name(coerceToNumber, "coerceToNumber");
-var StringDataType = createEnvGraphDataType(
-  (settings) => ({
-    name: "string",
-    icon: "carbon:string-text",
-    coerce: /* @__PURE__ */ __name((rawVal) => {
-      let val = coerceToString(rawVal);
-      if (settings?.toUpperCase) val = val.toUpperCase();
-      if (settings?.toLowerCase) val = val.toLowerCase();
-      return val;
-    }, "coerce"),
-    validate: /* @__PURE__ */ __name((val) => {
-      const errors = [];
-      if (settings?.minLength !== void 0 && val.length < settings.minLength) {
-        errors.push(new ValidationError(`Length must be more than ${settings.minLength}`));
-      }
-      if (settings?.maxLength !== void 0 && val.length > settings.maxLength) {
-        errors.push(new ValidationError(`Length must be less than ${settings.maxLength}`));
-      }
-      if (settings?.isLength !== void 0 && val.length !== settings.isLength) {
-        errors.push(new ValidationError(`Length must be exactly ${settings.isLength}`));
-      }
-      if (settings?.startsWith && !val.startsWith(settings.startsWith)) {
-        errors.push(new ValidationError(`Value must start with "${settings.startsWith}"`));
-      }
-      if (settings?.endsWith && !val.endsWith(settings.endsWith)) {
-        errors.push(new ValidationError(`Value must start with "${settings.endsWith}"`));
-      }
-      if (settings?.matches) {
-        const regex = my_dash_default.isString(settings.matches) ? new RegExp(settings.matches) : settings.matches;
-        const matches = val.match(regex);
-        if (!matches) {
-          errors.push(new ValidationError(`Value must match regex "${settings.matches}"`));
-        }
-      }
-      return errors.length ? errors : true;
-    }, "validate")
-  })
-);
-var NumberDataType = createEnvGraphDataType(
-  (settings) => ({
-    name: "number",
-    icon: "carbon:string-integer",
-    coerce(rawVal) {
-      let numVal = coerceToNumber(rawVal);
-      if (settings?.coerceToMinMaxRange) {
-        if (settings?.min !== void 0) numVal = Math.max(settings?.min, numVal);
-        if (settings?.max !== void 0) numVal = Math.min(settings?.max, numVal);
-      }
-      if (settings?.isInt === true || settings?.precision === 0) {
-        numVal = Math.round(numVal);
-      } else if (settings?.precision) {
-        const p = 10 ** settings.precision;
-        numVal = Math.round(numVal * p) / p;
-      }
-      return numVal;
-    },
-    validate(val) {
-      const errors = [];
-      if (settings?.min !== void 0 && val < settings?.min) {
-        errors.push(new ValidationError(`Min value is ${settings?.min}`));
-      }
-      if (settings?.max !== void 0 && val > settings?.max) {
-        errors.push(new ValidationError(`Max value is ${settings?.max}`));
-      }
-      if (settings?.isDivisibleBy !== void 0 && val % settings.isDivisibleBy !== 0) {
-        errors.push(new ValidationError(`Value must be divisible by ${settings?.isDivisibleBy}`));
-      }
-      return errors.length ? errors : true;
+  async _resolve() {
+    if (!this.refKey) throw new Error("expected refKey to be set");
+    return this.getDepValue(this.refKey);
+  }
+};
+var RegexResolver = class extends Resolver {
+  static {
+    __name(this, "RegexResolver");
+  }
+  static fnName = "regex";
+  label = "regex";
+  icon = "mdi:regex";
+  regex;
+  async _process() {
+    if (this.fnArgs.length !== 1) {
+      throw new SchemaError("regex() expects a single child arg");
     }
-  })
-);
-var BooleanDataType = createEnvGraphDataType({
-  name: "boolean",
-  icon: "carbon:boolean",
-  // probably want allow some settings
-  // - more strict about coercion or adding additional true/false values
-  // - coercing to other values - like 0,1
-  coerce(val) {
-    if (my_dash_default.isBoolean(val)) {
-      return val;
-    } else if (my_dash_default.isString(val)) {
-      const cleanVal = val.toLowerCase().trim();
-      if (["t", "true", "yes", "on", "1"].includes(cleanVal)) return true;
-      if (["f", "false", "no", "off", "0"].includes(cleanVal)) return false;
-      throw new CoercionError("Unable to coerce string value to boolean");
-    } else if (my_dash_default.isNumber(val)) {
-      if (val === 0) return false;
-      if (val === 1) return true;
-      throw new CoercionError("Unable to coerce number value to boolean (only 0 or 1 is valid)");
-    } else {
-      throw new CoercionError("Unable to coerce value to boolean");
+    if (!(this.fnArgs[0] instanceof StaticValueResolver)) {
+      throw new SchemaError("regex() expects a single static value passed in");
     }
-  },
-  // TODO: add settings to be more strict, or to allow other values to coerce to true/false
-  validate(val) {
-    if (my_dash_default.isBoolean(val)) return true;
-    return new ValidationError("Value must be `true` or `false`");
+    const regexStr = this.fnArgs[0].staticValue;
+    if (typeof regexStr !== "string") {
+      throw new SchemaError("regex() expects a string");
+    }
+    this.regex = new RegExp(regexStr);
   }
-});
-var UrlDataType = createEnvGraphDataType(
-  (settings) => ({
-    name: "url",
-    icon: "carbon:url",
-    coerce(rawVal) {
-      const val = coerceToString(rawVal);
-      if (settings?.prependHttps && !val.startsWith("https://")) return `https://${val}`;
-      return val;
-    },
-    validate(val) {
-      const url = new URL(val);
-      if (settings?.allowedDomains && !settings.allowedDomains.includes(url.host.toLowerCase())) {
-        return new ValidationError(`Domain (${url.host}) is not in allowed list: ${settings.allowedDomains.join(",")}`);
-      }
-      return true;
+  async _resolve() {
+    if (!this.regex) throw new Error("expected regex to be set");
+    return this.regex;
+  }
+};
+var RemapResolver = class extends Resolver {
+  static {
+    __name(this, "RemapResolver");
+  }
+  static fnName = "remap";
+  label = "remap";
+  icon = "codicon:replace";
+  remappings;
+  async _process() {
+    if (my_dash_default.isPlainObject(this.fnArgs[0])) {
+      throw new SchemaError("remap() expects the first arg to be the value to remap");
     }
-  })
-);
-var SimpleObjectDataType = createEnvGraphDataType({
-  name: "simple-object",
-  icon: "tabler:code-dots",
-  // curly brackets with nothing inside
-  coerce(val) {
-    if (my_dash_default.isPlainObject(val)) return val;
-    if (my_dash_default.isString(val)) {
-      try {
-        const parsedObj = JSON.parse(val);
-        if (my_dash_default.isPlainObject(parsedObj)) return parsedObj;
-        return new CoercionError("Unable to coerce JSON parsed string to object");
-      } catch (err) {
-        return new CoercionError("Error parsing JSON string while coercing string to object");
-      }
+    if (!my_dash_default.isPlainObject(this.fnArgs[1])) {
+      throw new SchemaError("remap() expects the all args after the first to be key-value pairs of remappings");
     }
-    return new CoercionError("Cannot coerce value to object");
-  },
-  validate(val) {
-    if (my_dash_default.isPlainObject(val)) return true;
-    return new ValidationError("Value must be an object");
+    if (this.fnArgs.length !== 2) {
+      throw new SchemaError("remap() should not have any additional non key-value args after remappings");
+    }
+    this.remappings = this.fnArgs[1];
   }
-});
-var EnumDataType = createEnvGraphDataType(
-  (...enumOptions) => ({
-    name: "enum",
-    icon: "material-symbols-light:category",
-    // a few shapes... not sure about this one
-    coerce(val) {
-      if (my_dash_default.isString(val) || my_dash_default.isNumber(val) || my_dash_default.isBoolean(val)) return val;
-      return new CoercionError("Value must be a string, number, or boolean");
-    },
-    validate(val) {
-      const possibleValues = enumOptions || [];
-      if (!possibleValues.includes(val)) {
-        throw new ValidationError("Current value is not in list of possible values", {
-          tip: `Possible values are: "${possibleValues.join('", "')}"`
-        });
-      }
-    },
-    _rawEnumOptions: enumOptions
-  })
-);
-var EMAIL_REGEX = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
-var EmailDataType = createEnvGraphDataType(
-  (settings) => ({
-    name: "email",
-    icon: "iconoir:at-sign",
-    typeDescription: "standard email address",
-    coerce(rawVal) {
-      let val = coerceToString(rawVal);
-      if (settings?.normalize) val = val.toLowerCase();
-      return val;
-    },
-    validate(val) {
-      const result = EMAIL_REGEX.test(val);
-      if (result) return true;
-      return new ValidationError("Value must be a valid email address");
+  async _resolve() {
+    if (my_dash_default.isPlainObject(this.fnArgs[0])) {
+      throw new SchemaError("remap() expects the first arg to be the value to remap");
     }
-  })
-);
-var IP_V4_ADDRESS_REGEX = /^(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}$/;
-var IP_V6_ADDRESS_REGEX = /^(?:(?:[a-fA-F\d]{1,4}:){7}(?:[a-fA-F\d]{1,4}|:)|(?:[a-fA-F\d]{1,4}:){6}(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|:[a-fA-F\d]{1,4}|:)|(?:[a-fA-F\d]{1,4}:){5}(?::(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,2}|:)|(?:[a-fA-F\d]{1,4}:){4}(?:(?::[a-fA-F\d]{1,4}){0,1}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,3}|:)|(?:[a-fA-F\d]{1,4}:){3}(?:(?::[a-fA-F\d]{1,4}){0,2}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,4}|:)|(?:[a-fA-F\d]{1,4}:){2}(?:(?::[a-fA-F\d]{1,4}){0,3}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,5}|:)|(?:[a-fA-F\d]{1,4}:){1}(?:(?::[a-fA-F\d]{1,4}){0,4}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,6}|:)|(?::(?:(?::[a-fA-F\d]{1,4}){0,5}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,7}|:)))(?:%[0-9a-zA-Z]{1,})?$/;
-var ipAddressDataType = createEnvGraphDataType(
-  (settings) => ({
-    name: "ip",
-    icon: "iconoir:ip-address-tag",
-    typeDescription: "ip v4 or v6 address",
-    coerce(rawVal) {
-      let val = coerceToString(rawVal);
-      if (settings?.normalize) val = val.toLowerCase();
-      return val;
-    },
-    validate(val) {
-      const regex = settings?.version === 6 ? IP_V6_ADDRESS_REGEX : IP_V4_ADDRESS_REGEX;
-      const result = regex.test(val);
-      if (result) return true;
-      return new ValidationError("Value must be a valid IP address");
+    if (!my_dash_default.isPlainObject(this.fnArgs[1])) {
+      throw new SchemaError("remap() expects the all args after the first to be key-value pairs of remappings");
     }
-  })
-);
-var PortDataType = createEnvGraphDataType(
-  (settings) => ({
-    name: "port",
-    icon: "material-symbols:captive-portal",
-    //! globe with arrow - not sure about this one
-    typeDescription: "valid port number between 0 and 65535",
-    coerce(rawVal) {
-      if (my_dash_default.isString(rawVal)) {
-        if (rawVal.includes(".")) throw new CoercionError("Port number must be an integer");
-        if (rawVal.includes("e")) throw new CoercionError("Port number should be an integer, not in exponential notation");
-      }
-      return coerceToNumber(rawVal);
-    },
-    validate(val) {
-      if (settings?.min !== void 0 && val < settings?.min) {
-        return new ValidationError(`Min value is ${settings?.min}`);
-      }
-      if (settings?.max !== void 0 && val > settings?.max) {
-        return new ValidationError(`Max value is ${settings?.max}`);
-      }
-      if (val < 0 || val > 65535) {
-        return new ValidationError("Value must be a valid port number (0-65535)");
+    const originalValue = await this.fnArgs[0].resolve();
+    if (!this.remappings) throw new Error("expected remappings to be set");
+    for (const [remappedVal, matchValResolver] of Object.entries(this.remappings)) {
+      const matchVal = await matchValResolver.resolve();
+      if (matchVal instanceof RegExp && originalValue !== void 0) {
+        if (matchVal.test(String(originalValue))) return remappedVal;
+      } else {
+        if (matchVal === originalValue) return remappedVal;
       }
-      return true;
-    }
-  })
-);
-var SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
-var SemverDataType = createEnvGraphDataType(
-  (settings) => ({
-    name: "semver",
-    icon: "simple-icons:semver",
-    typeDescription: "semantic version string",
-    validate(val) {
-      const result = SEMVER_REGEX.test(val);
-      if (result) return true;
-      return new ValidationError("Value must be a valid semantic version string");
     }
-  })
-);
-var ISO_DATE_REGEX = /^(?:[+-]?\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24:?00)(?:[.,]\d+(?!:))?)?(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[zZ]|(?:[+-])(?:[01]\d|2[0-3]):?(?:[0-5]\d)?)?)?)?$/;
-var IsoDateDataType = createEnvGraphDataType({
-  name: "isoDate",
-  icon: "formkit:datetime",
-  typeDescription: "ISO 8601 date string with optional time and milliseconds",
-  validate(val) {
-    const result = ISO_DATE_REGEX.test(val);
-    if (result) return true;
-    return new ValidationError("Value must be a valid ISO 8601 date string");
-  }
-});
-var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-var UuidDataType = createEnvGraphDataType({
-  name: "uuid",
-  icon: "mdi:identifier",
-  typeDescription: "UUID string V1-V5 per RFC4122, including NIL",
-  validate(val) {
-    const result = UUID_REGEX.test(val);
-    if (result) return true;
-    return new ValidationError("Value must be a valid UUID string");
-  }
-});
-var MD5_REGEX = /^[a-f0-9]{32}$/;
-var Md5DataType = createEnvGraphDataType({
-  name: "md5",
-  typeDescription: "MD5 hash string",
-  validate(val) {
-    const result = MD5_REGEX.test(val);
-    if (result) return true;
-    return new ValidationError("Value must be a valid MD5 hash string");
+    return originalValue;
   }
-});
-var BaseDataTypes = {
-  string: StringDataType,
-  number: NumberDataType,
-  boolean: BooleanDataType,
-  simpleObject: SimpleObjectDataType,
-  enum: EnumDataType,
-  email: EmailDataType,
-  url: UrlDataType,
-  ipAddress: ipAddressDataType,
-  port: PortDataType,
-  semver: SemverDataType,
-  isoDate: IsoDateDataType,
-  uuid: UuidDataType,
-  md5: Md5DataType
 };
+var BaseResolvers = [
+  ConcatResolver,
+  FallbackResolver,
+  RefResolver,
+  ExecResolver,
+  RemapResolver,
+  RegexResolver
+];
 
 // ../env-graph/src/lib/graph-utils.ts
 function findGraphCycles(graph) {
@@ -2052,15 +1596,15 @@ var iconCacheFolderInit = false;
 var iconInMemoryCache = {};
 async function fetchIconSvg(iconifyName, color = "808080", iconCacheFolder = "/tmp/varlock-icon-cache") {
   if (!iconCacheFolderInit) {
-    fs2.mkdirSync(iconCacheFolder, { recursive: true });
+    fs.mkdirSync(iconCacheFolder, { recursive: true });
     iconCacheFolderInit = true;
   }
   const iconPath = `${iconCacheFolder}/${iconifyName}-${ICON_SIZE}.svg`;
   let svgSrc;
   if (iconInMemoryCache[iconPath]) {
     svgSrc = iconInMemoryCache[iconPath];
-  } else if (fs2.existsSync(iconPath)) {
-    const svgFileBuffer = await fs2.promises.readFile(iconPath, "utf-8");
+  } else if (fs.existsSync(iconPath)) {
+    const svgFileBuffer = await fs.promises.readFile(iconPath, "utf-8");
     svgSrc = svgFileBuffer.toString();
     iconInMemoryCache[iconPath] = svgSrc;
   } else {
@@ -2072,7 +1616,7 @@ async function fetchIconSvg(iconifyName, color = "808080", iconCacheFolder = "/t
     }
     if (!svgSrc) return;
     if (svgSrc) {
-      await fs2.promises.writeFile(iconPath, svgSrc, "utf-8");
+      await fs.promises.writeFile(iconPath, svgSrc, "utf-8");
       iconInMemoryCache[iconPath] = svgSrc;
     }
   }
@@ -2163,12 +1707,23 @@ export type EnvSchemaAsStrings = {
       : (CoercedEnvSchema[Property] extends boolean ? ('true' | 'false') : string)
 };
 `);
-  tsSrc.push(`
-declare global {
+  const IMPORT_META_AUGMENTATION = `
+  // add types for global import.meta.env
+  interface ImportMetaEnv extends EnvSchemaAsStrings {}
+  interface ImportMeta {
+    readonly env: ImportMetaEnv;
+  }`;
+  const PROCESS_ENV_AUGMENTATION = `
+  // add types for global process.env
   namespace NodeJS {
     interface ProcessEnv extends EnvSchemaAsStrings {}
-  }
-}`);
+  }`;
+  tsSrc.push(...[
+    "declare global {",
+    IMPORT_META_AUGMENTATION,
+    PROCESS_ENV_AUGMENTATION,
+    "}"
+  ].filter(Boolean));
   return tsSrc.join("\n");
 }
 __name(generateTsTypesSrc, "generateTsTypesSrc");
@@ -2177,12 +1732,12 @@ async function generateTypes(graph, lang, outputPath) {
   const tsSrc = await generateTsTypesSrc(graph);
   if (!graph.basePath) return;
   const typesPath = path.join(graph.basePath, outputPath);
-  await fs2.promises.writeFile(typesPath, tsSrc, "utf-8");
+  await fs.promises.writeFile(typesPath, tsSrc, "utf-8");
 }
 __name(generateTypes, "generateTypes");
 
 // ../env-graph/src/lib/env-graph.ts
-var EnvGraph = class {
+var EnvGraph2 = class {
   static {
     __name(this, "EnvGraph");
   }
@@ -2227,241 +1782,654 @@ var EnvGraph = class {
     for (const dataType of my_dash_default.values(BaseDataTypes)) {
       this.registerDataType(dataType);
     }
-    for (const resolverClass of BaseResolvers) {
-      this.registerResolver(resolverClass);
+    for (const resolverClass of BaseResolvers) {
+      this.registerResolver(resolverClass);
+    }
+  }
+  async finishLoad() {
+    const sortedDataSources = this.sortedDataSources;
+    for (const source of sortedDataSources) {
+      if (source.loadingError) {
+        throw source.loadingError;
+      }
+      if (source.type === "example") {
+        source.disabled = true;
+        continue;
+      }
+      if (source.decorators?.envFlag) {
+        if (source.applyForEnv) {
+          throw new Error(`@envFlag cannot be set from within an env-specific data source - ${source.label}`);
+        } else if (this.envFlagKey) {
+          throw new Error("only a single @envFlag setting is allowed");
+        } else {
+          const envFlagKey = source.decorators.envFlag.simplifiedValue;
+          if (!my_dash_default.isString(envFlagKey)) {
+            throw new Error("@envFlag must be a string");
+          } else {
+            this.envFlagKey = envFlagKey;
+          }
+        }
+      }
+      if (source.applyForEnv) {
+        if (source.applyForEnv && this.envFlagValue !== source.applyForEnv) {
+          source.disabled = true;
+          continue;
+        }
+      }
+      if (source.decorators?.disable && source.decorators.disable.simplifiedValue) {
+        source.disabled = true;
+        continue;
+      }
+      for (const itemKey in source.configItemDefs) {
+        if (source.ignoreNewDefs && !this.configSchema[itemKey]) continue;
+        const itemDef = source.configItemDefs[itemKey];
+        this.configSchema[itemKey] ??= new ConfigItem3(this, itemKey);
+        this.configSchema[itemKey].addDef(itemDef, source);
+      }
+      if (source.type === "schema" && this.envFlagKey) {
+        if (!this.configSchema[this.envFlagKey]) {
+          throw new Error(`@envFlag key ${this.envFlagKey} not found in schema`);
+        }
+        const envFlagItem = this.configSchema[this.envFlagKey];
+        await envFlagItem.process();
+        for (const depKey of envFlagItem.valueResolver?.deps || []) {
+          const depItem = this.configSchema[depKey];
+          if (!depItem) {
+            throw new Error(`envFlag resolver is using non-existant dependency: ${depKey}`);
+          }
+          await depItem.process();
+          if (depItem.valueResolver?.deps.length) {
+            throw new Error("envFlag cannot follow a chain of dependencies");
+          }
+          await depItem.resolve();
+        }
+        await envFlagItem.resolve();
+        if (!envFlagItem.isValid) {
+          const err = new Error("resolved @envFlag value is not valid");
+          err.cause = envFlagItem.errors[0];
+          throw err;
+        }
+        if (envFlagItem.resolvedValue) {
+          if (!my_dash_default.isString(envFlagItem.resolvedValue)) {
+            throw new Error("expected resolved @envFlag value to be a string");
+          }
+          this.envFlagValue = envFlagItem.resolvedValue;
+        }
+      }
+    }
+    for (const itemKey in this.configSchema) {
+      const item = this.configSchema[itemKey];
+      await item.process();
+    }
+    const cycles = findGraphCycles(this.graphAdjacencyList);
+    for (const cycleItemKeys of cycles) {
+      for (const itemKey of cycleItemKeys) {
+        const item = this.configSchema[itemKey];
+        item.schemaErrors.push(
+          new SchemaError(
+            cycleItemKeys.length === 1 ? "Item cannot have dependency on itself" : `Dependency cycle detected: (${cycleItemKeys.join(", ")})`
+          )
+        );
+      }
+    }
+  }
+  get graphAdjacencyList() {
+    const adjList = {};
+    for (const itemKey in this.configSchema) {
+      const item = this.configSchema[itemKey];
+      adjList[itemKey] = item.valueResolver?.deps || [];
+    }
+    return adjList;
+  }
+  async resolveEnvValues() {
+    const adjList = this.graphAdjacencyList;
+    const reverseAdjList = {};
+    for (const itemKey in adjList) {
+      const itemDeps = adjList[itemKey];
+      for (const dep of itemDeps) {
+        reverseAdjList[dep] ??= [];
+        reverseAdjList[dep].push(itemKey);
+      }
+    }
+    const itemsToResolveStatus = my_dash_default.mapValues(this.configSchema, () => false);
+    const deferred = new Promise((resolve, reject) => {
+      const markItemCompleted = /* @__PURE__ */ __name((itemKey) => {
+        delete itemsToResolveStatus[itemKey];
+        if (reverseAdjList[itemKey]) {
+          reverseAdjList[itemKey].forEach(resolveItem);
+        }
+        if (my_dash_default.keys(itemsToResolveStatus).length === 0) resolve();
+      }, "markItemCompleted");
+      const resolveItem = /* @__PURE__ */ __name(async (itemKey) => {
+        if (itemsToResolveStatus[itemKey] !== false) return;
+        const item = this.configSchema[itemKey];
+        if (item.errors.length) {
+          markItemCompleted(itemKey);
+          return;
+        }
+        for (const depKey of adjList[itemKey]) {
+          const depItem = this.configSchema[depKey];
+          if (depItem.validationState === "error") {
+            item.resolutionError = new ResolutionError(`Dependency ${depKey} is invalid`);
+            markItemCompleted(itemKey);
+            return;
+          } else if (depKey in itemsToResolveStatus) {
+            return;
+          }
+        }
+        itemsToResolveStatus[itemKey] = true;
+        await item.resolve();
+        markItemCompleted(itemKey);
+      }, "resolveItem");
+      for (const itemKey in this.configSchema) {
+        resolveItem(itemKey);
+      }
+    });
+    return deferred;
+  }
+  getResolvedEnvObject() {
+    const envObject = {};
+    for (const itemKey in this.configSchema) {
+      const item = this.configSchema[itemKey];
+      envObject[itemKey] = item.resolvedValue;
+    }
+    return envObject;
+  }
+  getSerializedGraph() {
+    const serializedGraph = {
+      basePath: this.basePath,
+      sources: [],
+      config: {},
+      settings: {}
+    };
+    for (const source of this.sortedDataSources) {
+      serializedGraph.sources.push({
+        label: source.label,
+        enabled: !source.disabled,
+        path: source instanceof FileBasedDataSource ? path.relative(this.basePath ?? "", source.fullPath) : void 0
+      });
+    }
+    for (const itemKey in this.configSchema) {
+      const item = this.configSchema[itemKey];
+      serializedGraph.config[itemKey] = {
+        value: item.resolvedValue,
+        isSensitive: item.isSensitive
+      };
+    }
+    serializedGraph.settings.redactLogs = this.getRootDecoratorValue("redactLogs") ?? true;
+    serializedGraph.settings.preventLeaks = this.getRootDecoratorValue("preventLeaks") ?? true;
+    return serializedGraph;
+  }
+  get isInvalid() {
+    return my_dash_default.some(my_dash_default.values(this.configSchema), (i) => !i.isValid);
+  }
+  async generateTypes(lang, outputPath) {
+    await generateTypes(this, lang, outputPath);
+  }
+  getRootDecoratorValue(decoratorName) {
+    const dec = this.schemaDataSource?.decorators?.[decoratorName];
+    return dec?.simplifiedValue;
+  }
+};
+
+// ../env-graph/src/lib/config-item.ts
+var ConfigItem3 = class {
+  constructor(envGraph, key) {
+    this.envGraph = envGraph;
+    this.key = key;
+  }
+  static {
+    __name(this, "ConfigItem");
+  }
+  defs = [];
+  addDef(itemDef, source) {
+    this.defs.unshift({ itemDef, source });
+  }
+  get description() {
+    for (const def of this.defs) {
+      if (def.itemDef.description) return def.itemDef.description;
+    }
+  }
+  get icon() {
+    const explicitIcon = this.getDecoratorValueString("icon");
+    if (explicitIcon) return explicitIcon;
+    return this.dataType?.icon;
+  }
+  get docsLinks() {
+    const links = [];
+    const docsUrl = this.getDecoratorValueString("docsUrl");
+    if (docsUrl) links.push({ url: docsUrl });
+    return links;
+  }
+  get valueResolver() {
+    for (const def of this.defs) {
+      if (def.itemDef.resolver) return def.itemDef.resolver;
+    }
+  }
+  getDecorator(decoratorName) {
+    for (const def of this.defs) {
+      const defDecorators = def.itemDef.decorators || {};
+      if (decoratorName in defDecorators) {
+        return defDecorators[decoratorName];
+      }
+    }
+  }
+  getDecoratorValueRaw(decoratorName) {
+    for (const def of this.defs) {
+      const defDecorators = def.itemDef.decorators || {};
+      if (decoratorName in defDecorators) {
+        return defDecorators[decoratorName].value;
+      }
+    }
+  }
+  getDecoratorValueString(decoratorName) {
+    const dec = this.getDecoratorValueRaw(decoratorName);
+    if (dec instanceof ParsedEnvSpecStaticValue) return String(dec.value);
+  }
+  dataType;
+  schemaErrors = [];
+  get resolverSchemaErrors() {
+    return this.valueResolver?.schemaErrors || [];
+  }
+  async process() {
+    const finalOverrideDef = this.envGraph.finalOverridesDataSource?.configItemDefs[this.key];
+    if (finalOverrideDef) {
+      this.defs.unshift({ itemDef: finalOverrideDef, source: this.envGraph.finalOverridesDataSource });
+    }
+    for (const def of this.defs) {
+      await def.itemDef.resolver?.process(this);
+    }
+    const typeDecoratorValue = this.getDecoratorValueRaw("type");
+    let dataTypeName;
+    let dataTypeArgs;
+    if (typeDecoratorValue instanceof ParsedEnvSpecStaticValue) {
+      dataTypeName = typeDecoratorValue.value;
+    } else if (typeDecoratorValue instanceof ParsedEnvSpecFunctionCall) {
+      dataTypeName = typeDecoratorValue.name;
+      dataTypeArgs = typeDecoratorValue.simplifiedArgs;
+    }
+    if (!dataTypeName) {
+      if (this.valueResolver?.inferredType) {
+        dataTypeName = this.valueResolver.inferredType;
+      }
+    }
+    dataTypeName ||= "string";
+    dataTypeArgs ||= [];
+    if (!(dataTypeName in this.envGraph.dataTypesRegistry)) {
+      this.schemaErrors.push(new SchemaError(`unknown data type: ${dataTypeName}`));
+    } else {
+      const dataTypeFactory = this.envGraph.dataTypesRegistry[dataTypeName];
+      this.dataType = dataTypeFactory(...my_dash_default.isPlainObject(dataTypeArgs) ? [dataTypeArgs] : dataTypeArgs);
     }
   }
-  async finishLoad() {
-    const sortedDataSources = this.sortedDataSources;
-    for (const source of sortedDataSources) {
-      if (source.loadingError) {
-        throw source.loadingError;
+  get isRequired() {
+    for (const def of this.defs) {
+      const defDecorators = def.itemDef.decorators || {};
+      if ("required" in defDecorators) {
+        const val = defDecorators.required.simplifiedValue;
+        if (typeof val === "boolean") return val;
+        if (typeof val === "string") return val === "true";
+        return Boolean(val);
       }
-      if (source.decorators?.envFlag) {
-        if (source.applyForEnv) {
-          throw new Error(`@envFlag cannot be set from within an env-specific data source - ${source.label}`);
-        } else if (this.envFlagKey) {
-          throw new Error("only a single @envFlag setting is allowed");
-        } else {
-          const envFlagKey = source.decorators.envFlag.simplifiedValue;
-          if (!my_dash_default.isString(envFlagKey)) {
-            throw new Error("@envFlag must be a string");
+      if ("optional" in defDecorators) {
+        const val = defDecorators.optional.simplifiedValue;
+        if (typeof val === "boolean") return !val;
+        if (typeof val === "string") return val !== "true";
+        return !val;
+      }
+      if ("defaultRequired" in def.source.decorators) {
+        const val = def.source.decorators.defaultRequired.simplifiedValue;
+        if (val === "infer") {
+          if (def.source.type === "schema") {
+            const resolver = def.itemDef.resolver;
+            if (resolver instanceof StaticValueResolver) {
+              return resolver.staticValue !== void 0 && resolver.staticValue !== "";
+            } else {
+              return true;
+            }
           } else {
-            this.envFlagKey = envFlagKey;
+            continue;
           }
         }
+        return val;
       }
-      if (source.applyForEnv) {
-        if (source.applyForEnv && this.envFlagValue !== source.applyForEnv) {
-          source.disabled = true;
-          continue;
+    }
+    return true;
+  }
+  get isSensitive() {
+    for (const def of this.defs) {
+      const defDecorators = def.itemDef.decorators || {};
+      if ("sensitive" in defDecorators) {
+        return defDecorators.sensitive.simplifiedValue;
+      } else if ("defaultSensitive" in def.source.decorators) {
+        const dec = def.source.decorators.defaultSensitive;
+        if (dec.value instanceof ParsedEnvSpecFunctionCall && dec.value.name === "inferFromPrefix") {
+          const args = dec.value.simplifiedArgs;
+          const prefix = Array.isArray(args) && args.length > 0 ? args[0] : void 0;
+          if (typeof prefix === "string" && this.key.startsWith(prefix)) {
+            return false;
+          }
+          return true;
         }
+        return dec.simplifiedValue;
       }
-      if (source.decorators?.disable && source.decorators.disable.simplifiedValue) {
-        source.disabled = true;
-        continue;
+    }
+    return true;
+  }
+  get errors() {
+    return my_dash_default.compact([
+      ...this.schemaErrors || [],
+      ...this.resolverSchemaErrors || [],
+      this.resolutionError,
+      this.coercionError,
+      ...this.validationErrors || []
+    ]);
+  }
+  get validationState() {
+    const errors = this.errors;
+    if (!errors.length) return "valid";
+    return my_dash_default.some(errors, (e) => !e.isWarning) ? "error" : "warn";
+  }
+  /** resolved value _before coercion_ */
+  resolvedRawValue;
+  isResolved = false;
+  /** resolved value after coercion */
+  resolvedValue;
+  isValidated = false;
+  resolutionError;
+  coercionError;
+  validationErrors;
+  get isCoerced() {
+    return this.resolvedRawValue !== this.resolvedValue;
+  }
+  async resolve() {
+    if (this.schemaErrors.length) return;
+    if (this.resolverSchemaErrors.length) return;
+    if (!this.valueResolver) throw new Error("Expected a resolver to be set");
+    if (this.isResolved) {
+      return;
+    }
+    try {
+      this.resolvedRawValue = await this.valueResolver.resolve();
+    } catch (err) {
+      this.resolutionError = new ResolutionError(`error resolving value: ${err}`);
+      this.resolutionError.cause = err;
+    }
+    if (this.resolvedRawValue instanceof RegExp) {
+      this.resolutionError = new ResolutionError("regex() is meant to be used within function args, not as a final resolved value");
+    }
+    if (this.resolutionError) return;
+    this.isResolved = true;
+    if (this.resolvedRawValue === void 0 || this.resolvedRawValue === "") {
+      this.resolvedValue = this.resolvedRawValue;
+      if (this.isRequired) {
+        this.validationErrors = [new EmptyRequiredValueError(void 0)];
       }
-      for (const itemKey in source.configItemDefs) {
-        if (source.ignoreNewDefs && !this.configSchema[itemKey]) continue;
-        const itemDef = source.configItemDefs[itemKey];
-        this.configSchema[itemKey] ??= new ConfigItem(this, itemKey);
-        this.configSchema[itemKey].addDef(itemDef, source);
+      return;
+    }
+    if (!this.dataType) throw new Error("expected dataType to be set");
+    try {
+      const coerceResult = this.dataType.coerce(this.resolvedRawValue);
+      if (coerceResult instanceof Error) throw coerceResult;
+      this.resolvedValue = coerceResult;
+    } catch (err) {
+      if (err instanceof CoercionError) {
+        this.coercionError = err;
+        return;
+      } else if (err instanceof Error) {
+        this.coercionError = new CoercionError("Unexpected error coercing value");
+        this.coercionError.cause = err;
+      } else {
+        this.coercionError = new CoercionError(`Unexpected non-error throw during coerce - ${err}`);
       }
-      if (source.type === "schema" && this.envFlagKey) {
-        if (!this.configSchema[this.envFlagKey]) {
-          throw new Error(`@envFlag key ${this.envFlagKey} not found in schema`);
-        }
-        const envFlagItem = this.configSchema[this.envFlagKey];
-        await envFlagItem.process();
-        for (const depKey of envFlagItem.valueResolver?.deps || []) {
-          const depItem = this.configSchema[depKey];
-          if (!depItem) {
-            throw new Error(`envFlag resolver is using non-existant dependency: ${depKey}`);
-          }
-          await depItem.process();
-          if (depItem.valueResolver?.deps.length) {
-            throw new Error("envFlag cannot follow a chain of dependencies");
-          }
-          await depItem.resolve();
-        }
-        await envFlagItem.resolve();
-        if (!envFlagItem.isValid) {
-          const err = new Error("resolved @envFlag value is not valid");
-          err.cause = envFlagItem.errors[0];
-          throw err;
-        }
-        if (envFlagItem.resolvedValue) {
-          if (!my_dash_default.isString(envFlagItem.resolvedValue)) {
-            throw new Error("expected resolved @envFlag value to be a string");
-          }
-          this.envFlagValue = envFlagItem.resolvedValue;
-        }
+      return;
+    }
+    try {
+      const validateResult = this.dataType.validate(this.resolvedValue);
+      if (validateResult instanceof Error || my_dash_default.isArray(validateResult) && validateResult[0] instanceof Error) throw validateResult;
+      if (validateResult === false) {
+        throw new ValidationError("validation failed with `false` return value");
+      }
+      this.isValidated = true;
+    } catch (err) {
+      if (my_dash_default.isArray(err)) {
+        this.validationErrors = err;
+      } else if (err instanceof ValidationError) {
+        this.validationErrors = [err];
+      } else if (err instanceof Error) {
+        const validationError = new ValidationError("Unexpected error during validation");
+        validationError.cause = err;
+        console.log(err);
+        this.validationErrors = [validationError];
+      } else {
+        const validationError = new ValidationError(`Unexpected non-error thrown during validation - ${err}`);
+        validationError.cause = err;
+        this.validationErrors = [validationError];
+      }
+      return;
+    }
+  }
+  get isValid() {
+    return this.validationState === "valid";
+  }
+};
+
+// ../env-graph/src/lib/data-source.ts
+var DATA_SOURCE_TYPES = Object.freeze({
+  schema: {
+    fileSuffixes: ["schema"],
+    precedence: 0
+  },
+  example: {
+    fileSuffixes: ["sample", "example"],
+    precedence: 1
+  },
+  defaults: {
+    fileSuffixes: ["default", "defaults"],
+    precedence: 2
+  },
+  values: {
+    fileSuffixes: [],
+    precedence: 3
+  },
+  overrides: {
+    fileSuffixes: ["local", "override"],
+    precedence: 4
+  }
+});
+var EnvGraphDataSource = class {
+  static {
+    __name(this, "EnvGraphDataSource");
+  }
+  static DATA_SOURCE_TYPES = DATA_SOURCE_TYPES;
+  // reference back to the graph
+  graph;
+  type = "values";
+  applyForEnv;
+  disabled = false;
+  ignoreNewDefs = false;
+  /** an error encountered while loading/parsing the data source */
+  loadingError;
+  get isValid() {
+    return !this.loadingError;
+  }
+  configItemDefs = {};
+  decorators = {};
+  getStaticValues() {
+    const obj = {};
+    for (const [key, def] of Object.entries(this.configItemDefs)) {
+      if (def.resolver instanceof StaticValueResolver) {
+        obj[key] = String(def.resolver.staticValue ?? "");
       }
     }
-    for (const itemKey in this.configSchema) {
-      const item = this.configSchema[itemKey];
-      await item.process();
+    return obj;
+  }
+};
+var ProcessEnvDataSource2 = class _ProcessEnvDataSource extends EnvGraphDataSource {
+  static {
+    __name(this, "ProcessEnvDataSource");
+  }
+  type = "overrides";
+  typeLabel = "process";
+  label = "process.env";
+  ignoreNewDefs = true;
+  static processEnvValues;
+  // ? do we want to set decorator values from env vars here? -- ex: _ENV_FLAG_KEY
+  // depends if we want those to work only within process.env
+  constructor() {
+    super();
+    if (!_ProcessEnvDataSource.processEnvValues) {
+      _ProcessEnvDataSource.processEnvValues = {};
+      for (const itemKey of Object.keys(process.env)) {
+        _ProcessEnvDataSource.processEnvValues[itemKey] = process.env[itemKey];
+      }
     }
-    const cycles = findGraphCycles(this.graphAdjacencyList);
-    for (const cycleItemKeys of cycles) {
-      for (const itemKey of cycleItemKeys) {
-        const item = this.configSchema[itemKey];
-        item.schemaErrors.push(
-          new SchemaError(
-            cycleItemKeys.length === 1 ? "Item cannot have dependency on itself" : `Dependency cycle detected: (${cycleItemKeys.join(", ")})`
-          )
-        );
+    for (const itemKey of Object.keys(_ProcessEnvDataSource.processEnvValues)) {
+      this.configItemDefs[itemKey] = {
+        resolver: new StaticValueResolver(_ProcessEnvDataSource.processEnvValues[itemKey])
+      };
+    }
+  }
+};
+var EnvSourceParseError = class extends Error {
+  constructor(message, location) {
+    super(message);
+    this.location = location;
+  }
+  static {
+    __name(this, "EnvSourceParseError");
+  }
+};
+var FileBasedDataSource = class extends EnvGraphDataSource {
+  static {
+    __name(this, "FileBasedDataSource");
+  }
+  isGitIgnored;
+  fullPath;
+  fileName;
+  rawContents;
+  get typeLabel() {
+    return this.constructor.format;
+  }
+  get label() {
+    return this.fileName;
+  }
+  static format = "unknown";
+  // no abstract static
+  static validFileExtensions = [];
+  get validFileExtensions() {
+    return this.constructor.validFileExtensions;
+  }
+  constructor(fullPath, opts) {
+    super();
+    this.fullPath = fullPath;
+    this.fileName = path.basename(fullPath);
+    if (opts?.overrideContents) {
+      this.rawContents = opts.overrideContents;
+      this.isGitIgnored = opts.overrideGitIgnored;
+    }
+    if (!this.fileName.startsWith(".env")) {
+      throw new Error('file name must start with ".env"');
+    }
+    const fileNameParts = this.fileName.substring(1).split(".");
+    const maybeExtension = fileNameParts[fileNameParts.length - 1];
+    if (this.validFileExtensions.includes(maybeExtension)) {
+      fileNameParts.pop();
+    }
+    const maybeFileType = fileNameParts[fileNameParts.length - 1];
+    for (const [possibleSourceType, possibleSourceSpec] of Object.entries(DATA_SOURCE_TYPES)) {
+      if (possibleSourceSpec.fileSuffixes.includes(maybeFileType)) {
+        this.type = possibleSourceType;
+        break;
       }
     }
+    if (this.type !== "values") fileNameParts.pop();
+    if (fileNameParts.length > 2) {
+      throw Error(`Unsure how to interpret filename - ${this.fileName}`);
+    } else if (fileNameParts.length === 2) {
+      this.applyForEnv = fileNameParts[1];
+      if (this.applyForEnv === "dev") this.applyForEnv = "development";
+      if (this.applyForEnv === "stage") this.applyForEnv = "staging";
+      if (this.applyForEnv === "prod") this.applyForEnv = "production";
+    }
   }
-  get graphAdjacencyList() {
-    const adjList = {};
-    for (const itemKey in this.configSchema) {
-      const item = this.configSchema[itemKey];
-      adjList[itemKey] = item.valueResolver?.deps || [];
+  // no async constructors... :(
+  async finishInit() {
+    if (!this.rawContents) {
+      this.isGitIgnored = await checkIsFileGitIgnored(this.fullPath);
+      this.rawContents = await fs2.readFile(this.fullPath, "utf8");
     }
-    return adjList;
+    await this._parseContents();
   }
-  async resolveEnvValues() {
-    const adjList = this.graphAdjacencyList;
-    const reverseAdjList = {};
-    for (const itemKey in adjList) {
-      const itemDeps = adjList[itemKey];
-      for (const dep of itemDeps) {
-        reverseAdjList[dep] ??= [];
-        reverseAdjList[dep].push(itemKey);
+};
+var DotEnvFileDataSource = class extends FileBasedDataSource {
+  static {
+    __name(this, "DotEnvFileDataSource");
+  }
+  static format = ".env";
+  static validFileExtensions = [];
+  // no extension for dotenv files!
+  parsedFile;
+  convertParserValueToResolvers(value) {
+    if (!this.graph) throw new Error("expected graph to be set");
+    if (value === void 0) {
+      return new StaticValueResolver(void 0);
+    } else if (value instanceof ParsedEnvSpecStaticValue) {
+      return new StaticValueResolver(value.unescapedValue);
+    } else if (value instanceof ParsedEnvSpecFunctionCall) {
+      const ResolverFnClass = this.graph.registeredResolverFunctions[value.name];
+      if (!ResolverFnClass) {
+        return new ErrorResolver(new SchemaError(`Unknown resolver function: ${value.name}()`));
       }
-    }
-    const itemsToResolveStatus = my_dash_default.mapValues(this.configSchema, () => false);
-    const deferred = new Promise((resolve, reject) => {
-      const markItemCompleted = /* @__PURE__ */ __name((itemKey) => {
-        delete itemsToResolveStatus[itemKey];
-        if (reverseAdjList[itemKey]) {
-          reverseAdjList[itemKey].forEach(resolveItem);
-        }
-        if (my_dash_default.keys(itemsToResolveStatus).length === 0) resolve();
-      }, "markItemCompleted");
-      const resolveItem = /* @__PURE__ */ __name(async (itemKey) => {
-        if (itemsToResolveStatus[itemKey] !== false) return;
-        const item = this.configSchema[itemKey];
-        if (item.errors.length) {
-          markItemCompleted(itemKey);
-          return;
-        }
-        for (const depKey of adjList[itemKey]) {
-          const depItem = this.configSchema[depKey];
-          if (depItem.validationState === "error") {
-            item.resolutionError = new ResolutionError(`Dependency ${depKey} is invalid`);
-            markItemCompleted(itemKey);
-            return;
-          } else if (depKey in itemsToResolveStatus) {
-            return;
+      const argsFromParser = value.data.args.values;
+      let keyValueArgs;
+      const argsAsResolversArray = [];
+      for (const arg of argsFromParser) {
+        if (arg instanceof ParsedEnvSpecKeyValuePair) {
+          keyValueArgs ??= {};
+          keyValueArgs[arg.key] = this.convertParserValueToResolvers(arg.value);
+        } else {
+          if (keyValueArgs) {
+            return new ErrorResolver(new SchemaError("After switching to key-value function args, cannot switch back"));
           }
+          argsAsResolversArray.push(this.convertParserValueToResolvers(arg));
         }
-        itemsToResolveStatus[itemKey] = true;
-        await item.resolve();
-        markItemCompleted(itemKey);
-      }, "resolveItem");
-      for (const itemKey in this.configSchema) {
-        resolveItem(itemKey);
       }
-    });
-    return deferred;
-  }
-  getResolvedEnvObject() {
-    const envObject = {};
-    for (const itemKey in this.configSchema) {
-      const item = this.configSchema[itemKey];
-      envObject[itemKey] = item.resolvedValue;
+      if (keyValueArgs) argsAsResolversArray.push(keyValueArgs);
+      return new ResolverFnClass(argsAsResolversArray);
+    } else {
+      throw new Error("Unknown value type");
     }
-    return envObject;
   }
-  getSerializedGraph() {
-    const serializedGraph = {
-      sources: [],
-      config: {},
-      settings: {}
-    };
-    for (const source of this.sortedDataSources) {
-      serializedGraph.sources.push({
-        label: source.label,
-        enabled: !source.disabled
-      });
-    }
-    for (const itemKey in this.configSchema) {
-      const item = this.configSchema[itemKey];
-      serializedGraph.config[itemKey] = {
-        value: item.resolvedValue,
-        isSensitive: item.isSensitive
+  async _parseContents() {
+    const rawContents = this.rawContents;
+    this.parsedFile = await tryCatch(
+      () => parseEnvSpecDotEnvFile(rawContents),
+      (error) => {
+        this.loadingError = new EnvSourceParseError(error.message, {
+          path: this.fullPath,
+          lineNumber: error.location.start.line,
+          colNumber: error.location.start.column,
+          lineStr: rawContents.split("\n")[error.location.start.line - 1]
+        });
+        this.loadingError.cause = error;
+      }
+    );
+    if (this.loadingError) return;
+    if (!this.parsedFile) throw new Error("Failed to parse .env file");
+    this.decorators = this.parsedFile.decoratorsObject;
+    if (!this.graph) throw new Error("expected graph to be set");
+    for (const item of this.parsedFile.configItems) {
+      item.processExpansion();
+      this.configItemDefs[item.key] = {
+        resolver: this.convertParserValueToResolvers(item.expandedValue),
+        description: item.description,
+        decorators: item.decoratorsObject
       };
     }
-    serializedGraph.settings.redactLogs = this.getRootDecoratorValue("redactLogs") ?? true;
-    serializedGraph.settings.preventLeaks = this.getRootDecoratorValue("preventLeaks") ?? true;
-    return serializedGraph;
-  }
-  get isInvalid() {
-    return my_dash_default.some(my_dash_default.values(this.configSchema), (i) => !i.isValid);
-  }
-  async generateTypes(lang, outputPath) {
-    await generateTypes(this, lang, outputPath);
-  }
-  getRootDecoratorValue(decoratorName) {
-    const dec = this.schemaDataSource?.decorators?.[decoratorName];
-    return dec?.simplifiedValue;
   }
 };
-var SKIP_FILE_TYPES = [".md", ".d.ts"];
-async function findEnvFiles(opts) {
-  const cwd = opts?.cwd || process.cwd();
-  const envFiles = [];
-  const filesWithinDir = await fs.readdir(cwd);
-  for (const fileName of filesWithinDir) {
-    if (fileName.startsWith(".env")) {
-      let skip = false;
-      for (const fileType of SKIP_FILE_TYPES) {
-        if (fileName.endsWith(fileType)) skip = true;
-      }
-      if (skip) continue;
-      envFiles.push(path.join(cwd, fileName));
-    }
-  }
-  return envFiles;
-}
-__name(findEnvFiles, "findEnvFiles");
-
-// ../env-graph/src/lib/loader.ts
-function autoDetectContextPath() {
-  const PWD = process.env.PWD;
-  if (!PWD) {
-    throw new Error("PWD is not set");
-  }
-  return PWD;
-}
-__name(autoDetectContextPath, "autoDetectContextPath");
-async function loadEnvGraph(opts) {
-  const contextPath = opts?.contextPath ?? autoDetectContextPath();
-  const graph = new EnvGraph();
-  graph.basePath = contextPath;
-  if (opts?.afterInit) {
-    await opts.afterInit(graph);
-  }
-  if (opts?.currentEnvFallback) {
-    graph.envFlagValue = opts.currentEnvFallback;
-  }
-  const envFilePaths = await findEnvFiles({
-    cwd: contextPath
-  });
-  for (const envFilePath of envFilePaths) {
-    const fileDataSource = new DotEnvFileDataSource(envFilePath);
-    graph.addDataSource(fileDataSource);
-    await fileDataSource.finishInit();
-  }
-  graph.finalOverridesDataSource = new ProcessEnvDataSource();
-  await graph.finishLoad();
-  return graph;
-}
-__name(loadEnvGraph, "loadEnvGraph");
 
-export { DotEnvFileDataSource, EnvSourceParseError, StaticValueResolver, checkIsFileGitIgnored, loadEnvGraph, my_dash_default };
-//# sourceMappingURL=chunk-TYL3Q4QG.js.map
-//# sourceMappingURL=chunk-TYL3Q4QG.js.map
+export { DotEnvFileDataSource, EnvGraph2 as EnvGraph, EnvSourceParseError, ProcessEnvDataSource2 as ProcessEnvDataSource, StaticValueResolver, checkIsFileGitIgnored, my_dash_default };
+//# sourceMappingURL=chunk-K2N2TG4M.js.map
+//# sourceMappingURL=chunk-K2N2TG4M.js.map