varlock 0.0.0 → 0.0.1

package/dist/chunk-HZADDTO5.js

@@ -0,0 +1,2310 @@
+import { __name } from './chunk-XN24GZXQ.js';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ParsedEnvSpecStaticValue, ParsedEnvSpecFunctionCall, ParsedEnvSpecKeyValuePair, parseEnvSpecDotEnvFile } from '@env-spec/parser';
+import fs2 from 'node:fs';
+
+// ../../node_modules/.pnpm/@sindresorhus+is@7.0.1/node_modules/@sindresorhus/is/distribution/index.js
+var typedArrayTypeNames = [
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array"
+];
+function isTypedArrayName(name) {
+  return typedArrayTypeNames.includes(name);
+}
+__name(isTypedArrayName, "isTypedArrayName");
+var objectTypeNames = [
+  "Function",
+  "Generator",
+  "AsyncGenerator",
+  "GeneratorFunction",
+  "AsyncGeneratorFunction",
+  "AsyncFunction",
+  "Observable",
+  "Array",
+  "Buffer",
+  "Blob",
+  "Object",
+  "RegExp",
+  "Date",
+  "Error",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "WeakRef",
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "DataView",
+  "Promise",
+  "URL",
+  "FormData",
+  "URLSearchParams",
+  "HTMLElement",
+  "NaN",
+  ...typedArrayTypeNames
+];
+function isObjectTypeName(name) {
+  return objectTypeNames.includes(name);
+}
+__name(isObjectTypeName, "isObjectTypeName");
+var primitiveTypeNames = [
+  "null",
+  "undefined",
+  "string",
+  "number",
+  "bigint",
+  "boolean",
+  "symbol"
+];
+function isPrimitiveTypeName(name) {
+  return primitiveTypeNames.includes(name);
+}
+__name(isPrimitiveTypeName, "isPrimitiveTypeName");
+var getObjectType = /* @__PURE__ */ __name((value) => {
+  const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
+  if (/HTML\w+Element/.test(objectTypeName) && isHtmlElement(value)) {
+    return "HTMLElement";
+  }
+  if (isObjectTypeName(objectTypeName)) {
+    return objectTypeName;
+  }
+  return void 0;
+}, "getObjectType");
+function detect(value) {
+  if (value === null) {
+    return "null";
+  }
+  switch (typeof value) {
+    case "undefined": {
+      return "undefined";
+    }
+    case "string": {
+      return "string";
+    }
+    case "number": {
+      return Number.isNaN(value) ? "NaN" : "number";
+    }
+    case "boolean": {
+      return "boolean";
+    }
+    case "function": {
+      return "Function";
+    }
+    case "bigint": {
+      return "bigint";
+    }
+    case "symbol": {
+      return "symbol";
+    }
+  }
+  if (isObservable(value)) {
+    return "Observable";
+  }
+  if (isArray(value)) {
+    return "Array";
+  }
+  if (isBuffer(value)) {
+    return "Buffer";
+  }
+  const tagType = getObjectType(value);
+  if (tagType) {
+    return tagType;
+  }
+  if (value instanceof String || value instanceof Boolean || value instanceof Number) {
+    throw new TypeError("Please don't use object wrappers for primitive types");
+  }
+  return "Object";
+}
+__name(detect, "detect");
+function hasPromiseApi(value) {
+  return isFunction(value?.then) && isFunction(value?.catch);
+}
+__name(hasPromiseApi, "hasPromiseApi");
+Object.assign(detect, {
+  all: isAll,
+  any: isAny,
+  array: isArray,
+  arrayBuffer: isArrayBuffer,
+  arrayLike: isArrayLike,
+  asyncFunction: isAsyncFunction,
+  asyncGenerator: isAsyncGenerator,
+  asyncGeneratorFunction: isAsyncGeneratorFunction,
+  asyncIterable: isAsyncIterable,
+  bigint: isBigint,
+  bigInt64Array: isBigInt64Array,
+  bigUint64Array: isBigUint64Array,
+  blob: isBlob,
+  boolean: isBoolean,
+  boundFunction: isBoundFunction,
+  buffer: isBuffer,
+  class: isClass,
+  dataView: isDataView,
+  date: isDate,
+  detect,
+  directInstanceOf: isDirectInstanceOf,
+  emptyArray: isEmptyArray,
+  emptyMap: isEmptyMap,
+  emptyObject: isEmptyObject,
+  emptySet: isEmptySet,
+  emptyString: isEmptyString,
+  emptyStringOrWhitespace: isEmptyStringOrWhitespace,
+  enumCase: isEnumCase,
+  error: isError,
+  evenInteger: isEvenInteger,
+  falsy: isFalsy,
+  float32Array: isFloat32Array,
+  float64Array: isFloat64Array,
+  formData: isFormData,
+  function: isFunction,
+  generator: isGenerator,
+  generatorFunction: isGeneratorFunction,
+  htmlElement: isHtmlElement,
+  infinite: isInfinite,
+  inRange: isInRange,
+  int16Array: isInt16Array,
+  int32Array: isInt32Array,
+  int8Array: isInt8Array,
+  integer: isInteger,
+  iterable: isIterable,
+  map: isMap,
+  nan: isNan,
+  nativePromise: isNativePromise,
+  negativeNumber: isNegativeNumber,
+  nodeStream: isNodeStream,
+  nonEmptyArray: isNonEmptyArray,
+  nonEmptyMap: isNonEmptyMap,
+  nonEmptyObject: isNonEmptyObject,
+  nonEmptySet: isNonEmptySet,
+  nonEmptyString: isNonEmptyString,
+  nonEmptyStringAndNotWhitespace: isNonEmptyStringAndNotWhitespace,
+  null: isNull,
+  nullOrUndefined: isNullOrUndefined,
+  number: isNumber,
+  numericString: isNumericString,
+  object: isObject,
+  observable: isObservable,
+  oddInteger: isOddInteger,
+  plainObject: isPlainObject,
+  positiveNumber: isPositiveNumber,
+  primitive: isPrimitive,
+  promise: isPromise,
+  propertyKey: isPropertyKey,
+  regExp: isRegExp,
+  safeInteger: isSafeInteger,
+  set: isSet,
+  sharedArrayBuffer: isSharedArrayBuffer,
+  string: isString,
+  symbol: isSymbol,
+  truthy: isTruthy,
+  tupleLike: isTupleLike,
+  typedArray: isTypedArray,
+  uint16Array: isUint16Array,
+  uint32Array: isUint32Array,
+  uint8Array: isUint8Array,
+  uint8ClampedArray: isUint8ClampedArray,
+  undefined: isUndefined,
+  urlInstance: isUrlInstance,
+  urlSearchParams: isUrlSearchParams,
+  urlString: isUrlString,
+  validDate: isValidDate,
+  validLength: isValidLength,
+  weakMap: isWeakMap,
+  weakRef: isWeakRef,
+  weakSet: isWeakSet,
+  whitespaceString: isWhitespaceString
+});
+function isAbsoluteModule2(remainder) {
+  return (value) => isInteger(value) && Math.abs(value % 2) === remainder;
+}
+__name(isAbsoluteModule2, "isAbsoluteModule2");
+function isAll(predicate, ...values) {
+  return predicateOnArray(Array.prototype.every, predicate, values);
+}
+__name(isAll, "isAll");
+function isAny(predicate, ...values) {
+  const predicates = isArray(predicate) ? predicate : [predicate];
+  return predicates.some((singlePredicate) => predicateOnArray(Array.prototype.some, singlePredicate, values));
+}
+__name(isAny, "isAny");
+function isArray(value, assertion) {
+  if (!Array.isArray(value)) {
+    return false;
+  }
+  if (!isFunction(assertion)) {
+    return true;
+  }
+  return value.every((element) => assertion(element));
+}
+__name(isArray, "isArray");
+function isArrayBuffer(value) {
+  return getObjectType(value) === "ArrayBuffer";
+}
+__name(isArrayBuffer, "isArrayBuffer");
+function isArrayLike(value) {
+  return !isNullOrUndefined(value) && !isFunction(value) && isValidLength(value.length);
+}
+__name(isArrayLike, "isArrayLike");
+function isAsyncFunction(value) {
+  return getObjectType(value) === "AsyncFunction";
+}
+__name(isAsyncFunction, "isAsyncFunction");
+function isAsyncGenerator(value) {
+  return isAsyncIterable(value) && isFunction(value.next) && isFunction(value.throw);
+}
+__name(isAsyncGenerator, "isAsyncGenerator");
+function isAsyncGeneratorFunction(value) {
+  return getObjectType(value) === "AsyncGeneratorFunction";
+}
+__name(isAsyncGeneratorFunction, "isAsyncGeneratorFunction");
+function isAsyncIterable(value) {
+  return isFunction(value?.[Symbol.asyncIterator]);
+}
+__name(isAsyncIterable, "isAsyncIterable");
+function isBigint(value) {
+  return typeof value === "bigint";
+}
+__name(isBigint, "isBigint");
+function isBigInt64Array(value) {
+  return getObjectType(value) === "BigInt64Array";
+}
+__name(isBigInt64Array, "isBigInt64Array");
+function isBigUint64Array(value) {
+  return getObjectType(value) === "BigUint64Array";
+}
+__name(isBigUint64Array, "isBigUint64Array");
+function isBlob(value) {
+  return getObjectType(value) === "Blob";
+}
+__name(isBlob, "isBlob");
+function isBoolean(value) {
+  return value === true || value === false;
+}
+__name(isBoolean, "isBoolean");
+function isBoundFunction(value) {
+  return isFunction(value) && !Object.hasOwn(value, "prototype");
+}
+__name(isBoundFunction, "isBoundFunction");
+function isBuffer(value) {
+  return value?.constructor?.isBuffer?.(value) ?? false;
+}
+__name(isBuffer, "isBuffer");
+function isClass(value) {
+  return isFunction(value) && value.toString().startsWith("class ");
+}
+__name(isClass, "isClass");
+function isDataView(value) {
+  return getObjectType(value) === "DataView";
+}
+__name(isDataView, "isDataView");
+function isDate(value) {
+  return getObjectType(value) === "Date";
+}
+__name(isDate, "isDate");
+function isDirectInstanceOf(instance, class_) {
+  if (instance === void 0 || instance === null) {
+    return false;
+  }
+  return Object.getPrototypeOf(instance) === class_.prototype;
+}
+__name(isDirectInstanceOf, "isDirectInstanceOf");
+function isEmptyArray(value) {
+  return isArray(value) && value.length === 0;
+}
+__name(isEmptyArray, "isEmptyArray");
+function isEmptyMap(value) {
+  return isMap(value) && value.size === 0;
+}
+__name(isEmptyMap, "isEmptyMap");
+function isEmptyObject(value) {
+  return isObject(value) && !isMap(value) && !isSet(value) && Object.keys(value).length === 0;
+}
+__name(isEmptyObject, "isEmptyObject");
+function isEmptySet(value) {
+  return isSet(value) && value.size === 0;
+}
+__name(isEmptySet, "isEmptySet");
+function isEmptyString(value) {
+  return isString(value) && value.length === 0;
+}
+__name(isEmptyString, "isEmptyString");
+function isEmptyStringOrWhitespace(value) {
+  return isEmptyString(value) || isWhitespaceString(value);
+}
+__name(isEmptyStringOrWhitespace, "isEmptyStringOrWhitespace");
+function isEnumCase(value, targetEnum) {
+  return Object.values(targetEnum).includes(value);
+}
+__name(isEnumCase, "isEnumCase");
+function isError(value) {
+  return getObjectType(value) === "Error";
+}
+__name(isError, "isError");
+function isEvenInteger(value) {
+  return isAbsoluteModule2(0)(value);
+}
+__name(isEvenInteger, "isEvenInteger");
+function isFalsy(value) {
+  return !value;
+}
+__name(isFalsy, "isFalsy");
+function isFloat32Array(value) {
+  return getObjectType(value) === "Float32Array";
+}
+__name(isFloat32Array, "isFloat32Array");
+function isFloat64Array(value) {
+  return getObjectType(value) === "Float64Array";
+}
+__name(isFloat64Array, "isFloat64Array");
+function isFormData(value) {
+  return getObjectType(value) === "FormData";
+}
+__name(isFormData, "isFormData");
+function isFunction(value) {
+  return typeof value === "function";
+}
+__name(isFunction, "isFunction");
+function isGenerator(value) {
+  return isIterable(value) && isFunction(value?.next) && isFunction(value?.throw);
+}
+__name(isGenerator, "isGenerator");
+function isGeneratorFunction(value) {
+  return getObjectType(value) === "GeneratorFunction";
+}
+__name(isGeneratorFunction, "isGeneratorFunction");
+var NODE_TYPE_ELEMENT = 1;
+var DOM_PROPERTIES_TO_CHECK = [
+  "innerHTML",
+  "ownerDocument",
+  "style",
+  "attributes",
+  "nodeValue"
+];
+function isHtmlElement(value) {
+  return isObject(value) && value.nodeType === NODE_TYPE_ELEMENT && isString(value.nodeName) && !isPlainObject(value) && DOM_PROPERTIES_TO_CHECK.every((property) => property in value);
+}
+__name(isHtmlElement, "isHtmlElement");
+function isInfinite(value) {
+  return value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY;
+}
+__name(isInfinite, "isInfinite");
+function isInRange(value, range) {
+  if (isNumber(range)) {
+    return value >= Math.min(0, range) && value <= Math.max(range, 0);
+  }
+  if (isArray(range) && range.length === 2) {
+    return value >= Math.min(...range) && value <= Math.max(...range);
+  }
+  throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
+}
+__name(isInRange, "isInRange");
+function isInt16Array(value) {
+  return getObjectType(value) === "Int16Array";
+}
+__name(isInt16Array, "isInt16Array");
+function isInt32Array(value) {
+  return getObjectType(value) === "Int32Array";
+}
+__name(isInt32Array, "isInt32Array");
+function isInt8Array(value) {
+  return getObjectType(value) === "Int8Array";
+}
+__name(isInt8Array, "isInt8Array");
+function isInteger(value) {
+  return Number.isInteger(value);
+}
+__name(isInteger, "isInteger");
+function isIterable(value) {
+  return isFunction(value?.[Symbol.iterator]);
+}
+__name(isIterable, "isIterable");
+function isMap(value) {
+  return getObjectType(value) === "Map";
+}
+__name(isMap, "isMap");
+function isNan(value) {
+  return Number.isNaN(value);
+}
+__name(isNan, "isNan");
+function isNativePromise(value) {
+  return getObjectType(value) === "Promise";
+}
+__name(isNativePromise, "isNativePromise");
+function isNegativeNumber(value) {
+  return isNumber(value) && value < 0;
+}
+__name(isNegativeNumber, "isNegativeNumber");
+function isNodeStream(value) {
+  return isObject(value) && isFunction(value.pipe) && !isObservable(value);
+}
+__name(isNodeStream, "isNodeStream");
+function isNonEmptyArray(value) {
+  return isArray(value) && value.length > 0;
+}
+__name(isNonEmptyArray, "isNonEmptyArray");
+function isNonEmptyMap(value) {
+  return isMap(value) && value.size > 0;
+}
+__name(isNonEmptyMap, "isNonEmptyMap");
+function isNonEmptyObject(value) {
+  return isObject(value) && !isMap(value) && !isSet(value) && Object.keys(value).length > 0;
+}
+__name(isNonEmptyObject, "isNonEmptyObject");
+function isNonEmptySet(value) {
+  return isSet(value) && value.size > 0;
+}
+__name(isNonEmptySet, "isNonEmptySet");
+function isNonEmptyString(value) {
+  return isString(value) && value.length > 0;
+}
+__name(isNonEmptyString, "isNonEmptyString");
+function isNonEmptyStringAndNotWhitespace(value) {
+  return isString(value) && !isEmptyStringOrWhitespace(value);
+}
+__name(isNonEmptyStringAndNotWhitespace, "isNonEmptyStringAndNotWhitespace");
+function isNull(value) {
+  return value === null;
+}
+__name(isNull, "isNull");
+function isNullOrUndefined(value) {
+  return isNull(value) || isUndefined(value);
+}
+__name(isNullOrUndefined, "isNullOrUndefined");
+function isNumber(value) {
+  return typeof value === "number" && !Number.isNaN(value);
+}
+__name(isNumber, "isNumber");
+function isNumericString(value) {
+  return isString(value) && !isEmptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
+}
+__name(isNumericString, "isNumericString");
+function isObject(value) {
+  return !isNull(value) && (typeof value === "object" || isFunction(value));
+}
+__name(isObject, "isObject");
+function isObservable(value) {
+  if (!value) {
+    return false;
+  }
+  if (value === value[Symbol.observable]?.()) {
+    return true;
+  }
+  if (value === value["@@observable"]?.()) {
+    return true;
+  }
+  return false;
+}
+__name(isObservable, "isObservable");
+function isOddInteger(value) {
+  return isAbsoluteModule2(1)(value);
+}
+__name(isOddInteger, "isOddInteger");
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+__name(isPlainObject, "isPlainObject");
+function isPositiveNumber(value) {
+  return isNumber(value) && value > 0;
+}
+__name(isPositiveNumber, "isPositiveNumber");
+function isPrimitive(value) {
+  return isNull(value) || isPrimitiveTypeName(typeof value);
+}
+__name(isPrimitive, "isPrimitive");
+function isPromise(value) {
+  return isNativePromise(value) || hasPromiseApi(value);
+}
+__name(isPromise, "isPromise");
+function isPropertyKey(value) {
+  return isAny([isString, isNumber, isSymbol], value);
+}
+__name(isPropertyKey, "isPropertyKey");
+function isRegExp(value) {
+  return getObjectType(value) === "RegExp";
+}
+__name(isRegExp, "isRegExp");
+function isSafeInteger(value) {
+  return Number.isSafeInteger(value);
+}
+__name(isSafeInteger, "isSafeInteger");
+function isSet(value) {
+  return getObjectType(value) === "Set";
+}
+__name(isSet, "isSet");
+function isSharedArrayBuffer(value) {
+  return getObjectType(value) === "SharedArrayBuffer";
+}
+__name(isSharedArrayBuffer, "isSharedArrayBuffer");
+function isString(value) {
+  return typeof value === "string";
+}
+__name(isString, "isString");
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+__name(isSymbol, "isSymbol");
+function isTruthy(value) {
+  return Boolean(value);
+}
+__name(isTruthy, "isTruthy");
+function isTupleLike(value, guards) {
+  if (isArray(guards) && isArray(value) && guards.length === value.length) {
+    return guards.every((guard, index) => guard(value[index]));
+  }
+  return false;
+}
+__name(isTupleLike, "isTupleLike");
+function isTypedArray(value) {
+  return isTypedArrayName(getObjectType(value));
+}
+__name(isTypedArray, "isTypedArray");
+function isUint16Array(value) {
+  return getObjectType(value) === "Uint16Array";
+}
+__name(isUint16Array, "isUint16Array");
+function isUint32Array(value) {
+  return getObjectType(value) === "Uint32Array";
+}
+__name(isUint32Array, "isUint32Array");
+function isUint8Array(value) {
+  return getObjectType(value) === "Uint8Array";
+}
+__name(isUint8Array, "isUint8Array");
+function isUint8ClampedArray(value) {
+  return getObjectType(value) === "Uint8ClampedArray";
+}
+__name(isUint8ClampedArray, "isUint8ClampedArray");
+function isUndefined(value) {
+  return value === void 0;
+}
+__name(isUndefined, "isUndefined");
+function isUrlInstance(value) {
+  return getObjectType(value) === "URL";
+}
+__name(isUrlInstance, "isUrlInstance");
+function isUrlSearchParams(value) {
+  return getObjectType(value) === "URLSearchParams";
+}
+__name(isUrlSearchParams, "isUrlSearchParams");
+function isUrlString(value) {
+  if (!isString(value)) {
+    return false;
+  }
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isUrlString, "isUrlString");
+function isValidDate(value) {
+  return isDate(value) && !isNan(Number(value));
+}
+__name(isValidDate, "isValidDate");
+function isValidLength(value) {
+  return isSafeInteger(value) && value >= 0;
+}
+__name(isValidLength, "isValidLength");
+function isWeakMap(value) {
+  return getObjectType(value) === "WeakMap";
+}
+__name(isWeakMap, "isWeakMap");
+function isWeakRef(value) {
+  return getObjectType(value) === "WeakRef";
+}
+__name(isWeakRef, "isWeakRef");
+function isWeakSet(value) {
+  return getObjectType(value) === "WeakSet";
+}
+__name(isWeakSet, "isWeakSet");
+function isWhitespaceString(value) {
+  return isString(value) && /^\s+$/.test(value);
+}
+__name(isWhitespaceString, "isWhitespaceString");
+function predicateOnArray(method, predicate, values) {
+  if (!isFunction(predicate)) {
+    throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);
+  }
+  if (values.length === 0) {
+    throw new TypeError("Invalid number of values");
+  }
+  return method.call(values, predicate);
+}
+__name(predicateOnArray, "predicateOnArray");
+function keysOf(value) {
+  return Object.keys(value);
+}
+__name(keysOf, "keysOf");
+
+// ../utils/src/my-dash.ts
+function keyBy(array, key) {
+  return (array || []).reduce((r, x) => ({ ...r, [String(x[key])]: x }), {});
+}
+__name(keyBy, "keyBy");
+function sortBy(array, compareBy) {
+  if (typeof compareBy === "function") {
+    const compareMap = /* @__PURE__ */ new Map();
+    array.forEach((item) => {
+      compareMap.set(item, compareBy(item));
+    });
+    return array.concat().sort(
+      (a, b) => compareMap.get(a) - compareMap.get(b)
+    );
+  } else {
+    return array.concat().sort(
+      (a, b) => {
+        if (a[compareBy] > b[compareBy]) return 1;
+        return b[compareBy] > a[compareBy] ? -1 : 0;
+      }
+    );
+  }
+}
+__name(sortBy, "sortBy");
+function compact(array) {
+  return array.filter((item) => item !== void 0 && item !== false && item !== null);
+}
+__name(compact, "compact");
+function filter(array, fn) {
+  return array.filter(fn);
+}
+__name(filter, "filter");
+function each(array, fn) {
+  if (Array.isArray(array)) {
+    array.forEach((item, index) => fn(item, String(index)));
+  } else {
+    Object.entries(array).forEach(([key, value]) => fn(value, key));
+  }
+}
+__name(each, "each");
+function castArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+__name(castArray, "castArray");
+function mapValues(obj, fn) {
+  return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, fn(value)]));
+}
+__name(mapValues, "mapValues");
+function times(count, fn) {
+  return Array.from({ length: count }, (_2, i) => fn(i));
+}
+__name(times, "times");
+function map(array, fn) {
+  return array.map(fn);
+}
+__name(map, "map");
+function flatMap(array, fn) {
+  return array.flatMap(fn);
+}
+__name(flatMap, "flatMap");
+var _ = {
+  keyBy,
+  sortBy,
+  compact,
+  keys: Object.keys,
+  values: Object.values,
+  some: /* @__PURE__ */ __name((a, fn) => a.some(fn), "some"),
+  filter,
+  each,
+  castArray,
+  mapValues,
+  times,
+  map,
+  flatMap,
+  // type checks
+  isString,
+  isBoolean,
+  isError,
+  isPromise,
+  isFunction,
+  isNan,
+  isNumber,
+  isPlainObject,
+  isArray,
+  isInteger
+};
+var my_dash_default = _;
+var asyncExec = promisify(exec);
+
+// ../utils/src/git-utils.ts
+async function checkIsFileGitIgnored(path4, warnIfNotGitRepo = false) {
+  try {
+    await asyncExec(`git check-ignore ${path4} -q`);
+    return true;
+  } catch (err) {
+    if (err.stderr === "") return false;
+    if (err.stderr.includes("not a git repository")) {
+      if (warnIfNotGitRepo) {
+        console.log("\u{1F536} Your code is not currently in a git repository - run `git init` to initialize a new repo.");
+      }
+      return false;
+    }
+    throw err;
+  }
+}
+__name(checkIsFileGitIgnored, "checkIsFileGitIgnored");
+
+// ../utils/src/try-catch.ts
+function isPromise2(obj) {
+  return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
+}
+__name(isPromise2, "isPromise");
+async function tryCatch(tryFn, catchFn) {
+  try {
+    return await tryFn();
+  } catch (err) {
+    const catchResult = catchFn(err);
+    if (isPromise2(catchResult)) {
+      await catchResult;
+    }
+  }
+}
+__name(tryCatch, "tryCatch");
+
+// ../env-graph/src/lib/errors.ts
+var VarlockError = class extends Error {
+  constructor(errOrMessage, more) {
+    var __super = (...args) => {
+      super(...args);
+      this.more = more;
+      return this;
+    };
+    if (my_dash_default.isError(errOrMessage)) {
+      __super(errOrMessage.message);
+      this.originalError = errOrMessage;
+      this.icon = "\u{1F4A5}";
+    } else {
+      __super(errOrMessage);
+      this.originalError = more?.err;
+    }
+    if (my_dash_default.isArray(more?.tip)) more.tip = more.tip.join("\n");
+    this.name = this.constructor.name;
+    if (more?.isWarning) this.isWarning = true;
+    this.icon ||= this.constructor.defaultIcon;
+  }
+  static {
+    __name(this, "VarlockError");
+  }
+  originalError;
+  get isUnexpected() {
+    return !!this.originalError;
+  }
+  get type() {
+    return this.name;
+  }
+  static defaultIcon = "\u274C";
+  icon;
+  _isWarning = false;
+  get tip() {
+    if (!this.more?.tip) return void 0;
+    if (my_dash_default.isArray(this.more.tip)) return this.more.tip.join("\n");
+    return this.more.tip;
+  }
+  get code() {
+    return this.more?.code;
+  }
+  get extraMetadata() {
+    return this.more?.extraMetadata;
+  }
+  set isWarning(w) {
+    this._isWarning = w;
+    if (this._isWarning) {
+      this.icon = "\u{1F9D0}";
+    }
+  }
+  get isWarning() {
+    return this._isWarning;
+  }
+  toJSON() {
+    return {
+      icon: this.icon,
+      type: this.type,
+      name: this.name,
+      message: this.message,
+      isUnexpected: this.isUnexpected,
+      ...this.tip && { tip: this.tip },
+      ...this.isWarning && { isWarning: this.isWarning }
+    };
+  }
+};
+var SchemaError = class extends VarlockError {
+  static {
+    __name(this, "SchemaError");
+  }
+  static defaultIcon = "\u{1F9F0}";
+};
+var ValidationError = class extends VarlockError {
+  static {
+    __name(this, "ValidationError");
+  }
+  static defaultIcon = "\u274C";
+};
+var CoercionError = class extends VarlockError {
+  static {
+    __name(this, "CoercionError");
+  }
+  static defaultIcon = "\u{1F6D1}";
+};
+var ResolutionError = class _ResolutionError extends VarlockError {
+  static {
+    __name(this, "ResolutionError");
+  }
+  static defaultIcon = "\u26D4";
+  _retryable = false;
+  set retryable(val) {
+    this._retryable = val;
+  }
+  get retryable() {
+    if (this._retryable) return true;
+    if (this.originalError instanceof _ResolutionError) return this.originalError.retryable;
+    return false;
+  }
+};
+var EmptyRequiredValueError = class extends ValidationError {
+  static {
+    __name(this, "EmptyRequiredValueError");
+  }
+  icon = "\u2753";
+  constructor(_val) {
+    super("Value is required but is currently empty");
+  }
+};
+
+// ../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 my_dash_default.isArray(this.fnArgs) ? this.fnArgs : my_dash_default.values(this.fnArgs);
+  }
+  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;
+    }
+  }
+  static {
+    __name(this, "StaticValueResolver");
+  }
+  label = "static";
+  icon = "bi:dash";
+  async _resolve() {
+    return this.staticValue;
+  }
+  async _process() {
+  }
+};
+var ErrorResolver = class extends Resolver {
+  static {
+    __name(this, "ErrorResolver");
+  }
+  constructor(err) {
+    super([]);
+    this._schemaErrors.push(err);
+  }
+  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 (!Array.isArray(this.fnArgs)) {
+      throw new SchemaError("concat() expects an array of arguments, not a key-value object");
+    }
+    if (this.fnArgs.length < 2) {
+      throw new SchemaError("concat() expects at least two arguments");
+    }
+  }
+  async _resolve() {
+    if (!Array.isArray(this.fnArgs)) {
+      throw new Error("concat() expects an array of arguments, not a key-value object");
+    }
+    const resolvedValues = [];
+    for (const arg of this.fnArgs) {
+      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 (!Array.isArray(this.fnArgs)) {
+      throw new SchemaError("fallback() expects an array of arguments, not a key-value object");
+    }
+    if (this.fnArgs.length < 2) {
+      throw new SchemaError("fallback() expects at least two arguments");
+    }
+  }
+  async _resolve() {
+    if (!Array.isArray(this.fnArgs)) {
+      throw new Error("concat() expects an array of arguments, not a key-value object");
+    }
+    for (const arg of this.fnArgs) {
+      const resolvedChildValue = await arg.resolve();
+      if (resolvedChildValue !== void 0 && resolvedChildValue !== "") {
+        return resolvedChildValue;
+      }
+    }
+  }
+};
+var ExecResolver = class _ExecResolver extends Resolver {
+  static {
+    __name(this, "ExecResolver");
+  }
+  static fnName = "exec";
+  label = "exec";
+  icon = "iconoir:terminal";
+  async _process() {
+    if (!Array.isArray(this.fnArgs)) {
+      throw new SchemaError("exec() expects a single child arg, not a key-value object");
+    }
+    if (this.fnArgs.length !== 1) {
+      throw new SchemaError("exec() expects a single child arg");
+    }
+  }
+  static execQueue = new SimpleQueue();
+  async _resolve() {
+    if (!Array.isArray(this.fnArgs) || this.fnArgs.length !== 1) {
+      throw new Error("exec() expects a single child arg");
+    }
+    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 (!Array.isArray(this.fnArgs)) {
+      throw new SchemaError("ref() expects a single child arg, not a key-value object");
+    }
+    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 BaseResolvers = [
+  ConcatResolver,
+  FallbackResolver,
+  RefResolver,
+  ExecResolver
+];
+
+// ../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 ?? "");
+      }
+    }
+    return obj;
+  }
+};
+var ProcessEnvDataSource = class _ProcessEnvDataSource extends EnvGraphDataSource {
+  static {
+    __name(this, "ProcessEnvDataSource");
+  }
+  type = "overrides";
+  label = "Process Environment Variables";
+  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];
+      }
+    }
+    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;
+  format;
+  get label() {
+    return `File: ${this.fullPath}`;
+  }
+  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";
+    }
+  }
+  // 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 DotEnvFileDataSource = class extends FileBasedDataSource {
+  static {
+    __name(this, "DotEnvFileDataSource");
+  }
+  static format = "dotenv";
+  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;
+      if (argsFromParser.length && argsFromParser.every((arg) => arg instanceof ParsedEnvSpecKeyValuePair)) {
+        const argsAsResolversObj = {};
+        for (const arg of argsFromParser) {
+          argsAsResolversObj[arg.key] = this.convertParserValueToResolvers(arg.value);
+        }
+        return new ResolverFnClass(argsAsResolversObj);
+      } else {
+        const argsAsResolversArray = argsFromParser.map((arg) => {
+          if (arg instanceof ParsedEnvSpecKeyValuePair) throw new Error("KeyValuePair not supported as a function argument");
+          return this.convertParserValueToResolvers(arg);
+        });
+        return new ResolverFnClass(argsAsResolversArray);
+      }
+    } else {
+      throw new Error("Unknown value type");
+    }
+  }
+  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
+      };
+    }
+  }
+};
+var ConfigItem = 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() {
+    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);
+    }
+  }
+  get isRequired() {
+    for (const def of this.defs) {
+      const defDecorators = def.itemDef.decorators || {};
+      if ("required" in defDecorators) {
+        return defDecorators.required.simplifiedValue;
+      } else if ("optional" in defDecorators) {
+        return !defDecorators.optional.simplifiedValue;
+      } else if ("defaultRequired" in def.source.decorators) {
+        return def.source.decorators.defaultRequired.simplifiedValue;
+      }
+    }
+    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) {
+        return def.source.decorators.defaultSensitive.simplifiedValue;
+      }
+    }
+    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) {
+      this.resolvedRawValue = void 0;
+      return;
+    }
+    if (this.isResolved) throw new Error("item already resolved");
+    try {
+      this.resolvedRawValue = await this.valueResolver.resolve();
+    } catch (err) {
+      this.resolutionError = new ResolutionError(`error resolving value: ${err}`);
+      this.resolutionError.cause = err;
+    }
+    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;
+    }
+    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;
+    }
+    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-types.ts
+var EnvGraphDataType = class {
+  constructor(def, factory) {
+    this.def = def;
+    this.factory = factory;
+  }
+  static {
+    __name(this, "EnvGraphDataType");
+  }
+  get name() {
+    return this.def.name;
+  }
+  get icon() {
+    return this.def.icon;
+  }
+  /** @internal */
+  get _rawDef() {
+    return this.def;
+  }
+  coerce(val) {
+    return this.def.coerce ? this.def.coerce(val) : val;
+  }
+  validate(val) {
+    return this.def.validate ? this.def.validate(val) : true;
+  }
+};
+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");
+    }
+    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`);
+  }
+  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;
+    }
+  })
+);
+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");
+    }
+  },
+  // 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 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;
+    }
+  })
+);
+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");
+      }
+    }
+    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");
+    }
+  })
+);
+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");
+    }
+  })
+);
+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;
+    }
+  })
+);
+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");
+  }
+});
+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
+};
+
+// ../env-graph/src/lib/graph-utils.ts
+function findGraphCycles(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  const cycles = [];
+  const currentPath = [];
+  function dfs(node) {
+    if (recursionStack.has(node)) {
+      const cycleStart = currentPath.indexOf(node);
+      const cycle = currentPath.slice(cycleStart);
+      cycles.push(cycle);
+      return;
+    }
+    if (visited.has(node)) {
+      return;
+    }
+    visited.add(node);
+    recursionStack.add(node);
+    currentPath.push(node);
+    for (const neighbor of graph[node] || []) {
+      dfs(neighbor);
+    }
+    recursionStack.delete(node);
+    currentPath.pop();
+  }
+  __name(dfs, "dfs");
+  for (const node of Object.keys(graph)) {
+    if (!visited.has(node)) {
+      dfs(node);
+    }
+  }
+  return cycles;
+}
+__name(findGraphCycles, "findGraphCycles");
+var AUTOGENERATED_FILE_BANNER = `
+// \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1}
+// \u{1F6D1} THIS IS AN AUTOGENERATED FILE - DO NOT EDIT DIRECTLY \u{1F6D1}
+// \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1} \u{1F6D1}
+`;
+var ICON_SIZE = 20;
+var iconCacheFolderInit = false;
+var iconInMemoryCache = {};
+async function fetchIconSvg(iconifyName, color = "808080", iconCacheFolder = "/tmp/varlock-icon-cache") {
+  if (!iconCacheFolderInit) {
+    fs2.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");
+    svgSrc = svgFileBuffer.toString();
+    iconInMemoryCache[iconPath] = svgSrc;
+  } else {
+    try {
+      const iconSvg = await fetch(`https://api.iconify.design/${iconifyName.replace(":", "/")}.svg?height=${ICON_SIZE}`);
+      svgSrc = await iconSvg.text();
+    } catch (err) {
+      return;
+    }
+    if (!svgSrc) return;
+    if (svgSrc) {
+      await fs2.promises.writeFile(iconPath, svgSrc, "utf-8");
+      iconInMemoryCache[iconPath] = svgSrc;
+    }
+  }
+  const hexColor = color.startsWith("#") ? color : `#${color}`;
+  const colorizedSvg = svgSrc.replaceAll("currentColor", hexColor);
+  return colorizedSvg;
+}
+__name(fetchIconSvg, "fetchIconSvg");
+async function getTsDefinitionForItem(item, indentLevel = 0) {
+  const i = my_dash_default.times(indentLevel, () => "  ").join("");
+  const itemSrc = [];
+  const jsDocLines = [];
+  jsDocLines.push(`**${item.key}**${item.isSensitive ? " \u{1F510} _sensitive_" : ""}`);
+  if (item.description) jsDocLines.push(...item.description.split("\n"));
+  const iconName = item.icon;
+  if (iconName) {
+    const iconSvg = await fetchIconSvg(iconName);
+    if (iconSvg) jsDocLines.push(`![icon](data:image/svg+xml;utf-8,${encodeURIComponent(iconSvg)}) `);
+  }
+  const docsLinks = item.docsLinks;
+  if (docsLinks.length) {
+    jsDocLines.push("");
+    docsLinks.forEach((docsEntry) => {
+      const docsLink = my_dash_default.compact([docsEntry.url, docsEntry.description]).join(" | ");
+      jsDocLines.push(`\u{1F4DA} {@link ${docsLink}}`);
+    });
+  }
+  if (jsDocLines.length === 1) {
+    itemSrc.push(`/** ${jsDocLines[0]} */`);
+  } else if (jsDocLines.length > 1) {
+    itemSrc.push(...[
+      "/**",
+      // extra 2 trailing spaces are needed to make line breaks visible
+      ...my_dash_default.flatMap(jsDocLines, (line) => [` * ${line}  `]),
+      " */"
+    ]);
+  }
+  const dataType = item.dataType;
+  const dataTypeName = dataType?.name;
+  let itemTsType = "string";
+  if (dataType) {
+    if (dataTypeName === "number" || dataTypeName === "port") {
+      itemTsType = "number";
+    } else if (dataTypeName === "boolean") {
+      itemTsType = "boolean";
+    } else if (dataTypeName === "simple-object") {
+      itemTsType = "Record<string, any>";
+    } else if (dataTypeName === "enum") {
+      const rawEnumOptions = dataType._rawDef._rawEnumOptions;
+      let enumOptions = [];
+      enumOptions = rawEnumOptions;
+      if (!enumOptions.length) {
+        itemTsType = "never";
+      } else {
+        itemTsType = my_dash_default.map(enumOptions, JSON.stringify).join(" | ");
+      }
+    }
+  }
+  itemSrc.push(`readonly ${item.key}${item.isRequired ? "" : "?"}: ${itemTsType};`);
+  itemSrc.push("");
+  return my_dash_default.map(itemSrc, (line) => `${i}${line}`);
+}
+__name(getTsDefinitionForItem, "getTsDefinitionForItem");
+async function generateTsTypesSrc(graph) {
+  const tsSrc = [
+    AUTOGENERATED_FILE_BANNER,
+    // might want to add some options to let users inject this, or somehow detect eslint, but fine for now
+    "/* eslint-disable */",
+    "export type CoercedEnvSchema = {"
+  ];
+  const exposedNonSensitiveKeys = [];
+  for (const itemKey in graph.configSchema) {
+    const configItem = graph.configSchema[itemKey];
+    tsSrc.push(...await getTsDefinitionForItem(configItem, 1));
+    if (!configItem.isSensitive) exposedNonSensitiveKeys.push(itemKey);
+  }
+  tsSrc.push("};\n");
+  tsSrc.push(`
+declare module 'varlock' {
+  export interface TypedEnvSchema extends CoercedEnvSchema {}
+  
+  export interface PublicTypedEnvSchema extends Pick<CoercedEnvSchema, '${exposedNonSensitiveKeys.join("' | '")}'> {}
+}
+`);
+  return tsSrc.join("\n");
+}
+__name(generateTsTypesSrc, "generateTsTypesSrc");
+async function generateTypes(graph, lang, outputPath) {
+  if (lang !== "ts") throw new Error(`Unsupported @generateTypes lang: ${lang}`);
+  const tsSrc = await generateTsTypesSrc(graph);
+  if (!graph.basePath) return;
+  const typesPath = path.join(graph.basePath, outputPath);
+  await fs2.promises.writeFile(typesPath, tsSrc, "utf-8");
+}
+__name(generateTypes, "generateTypes");
+
+// ../env-graph/src/lib/env-graph.ts
+var EnvGraph = class {
+  static {
+    __name(this, "EnvGraph");
+  }
+  // TODO: not sure if this should be the graph of _everything_ in a workspace/project
+  // or just the files that are relevant to the current resolution attempt
+  // (which would mean it's always through the lens of the current directory/package)
+  basePath;
+  /** array of data sources */
+  dataSources = [];
+  /** config item key of env flag (toggles env-specific data sources enabled) */
+  envFlagKey;
+  /** current value of the environment flag */
+  envFlagValue;
+  configSchema = {};
+  addDataSource(dataSource) {
+    dataSource.graph = this;
+    this.dataSources.push(dataSource);
+  }
+  get schemaDataSource() {
+    const schemas = this.dataSources.filter((f) => f.type === "schema");
+    if (schemas.length > 1) throw new Error("Multiple schema data sources found");
+    if (schemas.length === 0) return void 0;
+    return schemas[0];
+  }
+  get sortedDataSources() {
+    return my_dash_default.sortBy(this.dataSources, (f) => 10 * EnvGraphDataSource.DATA_SOURCE_TYPES[f.type].precedence + (f.applyForEnv ? 1 : 0));
+  }
+  registeredResolverFunctions = {};
+  registerResolver(resolverClass) {
+    const fnName = resolverClass.fnName;
+    if (fnName in this.registeredResolverFunctions) {
+      throw new Error(`Resolver ${fnName} already registered`);
+    }
+    this.registeredResolverFunctions[fnName] = resolverClass;
+  }
+  dataTypesRegistry = {};
+  registerDataType(factory) {
+    this.dataTypesRegistry[factory.dataTypeName] = factory;
+  }
+  constructor() {
+    for (const dataType of my_dash_default.values(BaseDataTypes)) {
+      this.registerDataType(dataType);
+    }
+    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.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 (!this.envFlagValue) {
+          if (!this.envFlagKey) {
+            throw new Error("You must specify the @envFlag in your schema to load any env-specific files");
+          }
+          if (!this.configSchema[this.envFlagKey]) {
+            throw new Error(`@envFlag key ${this.envFlagKey} not found in schema`);
+          }
+          if (process.env[this.envFlagKey]) {
+            this.envFlagValue = process.env[this.envFlagKey];
+          } else {
+            const envFlagResolver = this.configSchema[this.envFlagKey].valueResolver;
+            if (envFlagResolver instanceof StaticValueResolver) {
+              if (!my_dash_default.isString(envFlagResolver.staticValue)) throw new Error("expected a static string value for envFlag");
+              this.envFlagValue = envFlagResolver.staticValue;
+            } else {
+              throw new Error("envFlag value must be a static string");
+            }
+          }
+        }
+        if (source.applyForEnv && this.envFlagValue !== source.applyForEnv) {
+          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 ConfigItem(this, itemKey);
+        this.configSchema[itemKey].addDef(itemDef, source);
+      }
+    }
+    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;
+  }
+  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);
+  }
+};
+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);
+  }
+  const envFilePaths = await findEnvFiles({
+    cwd: contextPath
+  });
+  for (const envFilePath of envFilePaths) {
+    const fileDataSource = new DotEnvFileDataSource(envFilePath);
+    graph.addDataSource(fileDataSource);
+    await fileDataSource.finishInit();
+  }
+  graph.addDataSource(new ProcessEnvDataSource());
+  await graph.finishLoad();
+  return graph;
+}
+__name(loadEnvGraph, "loadEnvGraph");
+
+export { DotEnvFileDataSource, EnvSourceParseError, StaticValueResolver, checkIsFileGitIgnored, loadEnvGraph, my_dash_default };
+//# sourceMappingURL=chunk-HZADDTO5.js.map
+//# sourceMappingURL=chunk-HZADDTO5.js.map