varlock 0.6.4 → 0.7.0

package/dist/{chunk-MXPBXRWY.js → chunk-CU6IMJWG.js}

@@ -1,4 +1,4 @@
-import { createDebug } from './chunk-QZ6HBRJC.js';
+import { SchemaError, VarlockError, createDebug, ResolutionError, CoercionError, ValidationError, activatePlugin, deactivatePlugin, my_dash_default, EmptyRequiredValueError, ParseError, pluginProxy } from './chunk-6CCHLM3U.js';
 import { __commonJS, __name, __toESM } from './chunk-6PEHRAEP.js';
 import path2, { join } from 'path';
 import fs2, { access } from 'fs/promises';
@@ -7,6 +7,7 @@ import fs4, { accessSync, existsSync } from 'fs';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
 import crypto from 'crypto';
 import https from 'https';
 import { AsyncLocalStorage } from 'async_hooks';
@@ -63,7 +64,7 @@ var require_ansis = __commonJS({
       let s2 = { Ansis: e2, level: t2, isSupported: /* @__PURE__ */ __name(() => a3, "isSupported"), strip: /* @__PURE__ */ __name((e3) => e3.replace(/[›][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, i), "strip"), extend(e3) {
         for (let t3 in e3) {
           let r2 = e3[t3], l2 = (typeof r2)[0];
-          "s" === l2 ? (c2(t3, T(...p(r2))), c2(_3(t3), v(...p(r2)))) : c2(t3, r2, "f" === l2);
+          "s" === l2 ? (c2(t3, T(...p(r2))), c2(_2(t3), v(...p(r2)))) : c2(t3, r2, "f" === l2);
         }
         return r = o({}, O), n(s2, r), s2;
       } }, c2 = /* @__PURE__ */ __name((e3, t3, r2) => {
@@ -73,9 +74,9 @@ var require_ansis = __commonJS({
         } };
       }, "c"), a3 = t2 > 0, w2 = /* @__PURE__ */ __name((e3, t3) => a3 ? { open: `\x1B[${e3}m`, close: `\x1B[${t3}m` } : g, "w"), y = /* @__PURE__ */ __name((e3) => (t3) => e3(...p(t3)), "y"), R = /* @__PURE__ */ __name((e3, t3) => (r2, l2, n2) => w2(`${e3}8;2;${r2};${l2};${n2}`, t3), "R"), $ = /* @__PURE__ */ __name((e3, t3) => (r2, l2, n2) => w2(((e4, t4, r3) => d(u(e4, t4, r3)))(r2, l2, n2) + e3, t3), "$"), x = /* @__PURE__ */ __name((e3) => (t3, r2, l2) => e3(u(t3, r2, l2)), "x"), T = R(3, h), v = R(4, b), C = /* @__PURE__ */ __name((e3) => w2("38;5;" + e3, h), "C"), E = /* @__PURE__ */ __name((e3) => w2("48;5;" + e3, b), "E");
       2 === t2 ? (T = x(C), v = x(E)) : 1 === t2 && (T = $(0, h), v = $(10, b), C = /* @__PURE__ */ __name((e3) => w2(d(e3), h), "C"), E = /* @__PURE__ */ __name((e3) => w2(d(e3) + 10, b), "E"));
-      let M, I = { fg: C, bg: E, rgb: T, bgRgb: v, hex: y(T), bgHex: y(v), visible: g, reset: w2(0, 0), bold: w2(1, 22), dim: w2(2, 22), italic: w2(3, 23), underline: w2(4, 24), inverse: w2(7, 27), hidden: w2(8, 28), strikethrough: w2(9, 29) }, _3 = /* @__PURE__ */ __name((e3) => "bg" + e3[0].toUpperCase() + e3.slice(1), "_"), k = "Bright";
+      let M, I = { fg: C, bg: E, rgb: T, bgRgb: v, hex: y(T), bgHex: y(v), visible: g, reset: w2(0, 0), bold: w2(1, 22), dim: w2(2, 22), italic: w2(3, 23), underline: w2(4, 24), inverse: w2(7, 27), hidden: w2(8, 28), strikethrough: w2(9, 29) }, _2 = /* @__PURE__ */ __name((e3) => "bg" + e3[0].toUpperCase() + e3.slice(1), "_"), k = "Bright";
       return "black,red,green,yellow,blue,magenta,cyan,white,gray".split(",").map(((e3, t3) => {
-        M = _3(e3), 8 > t3 ? (I[e3 + k] = w2(90 + t3, h), I[M + k] = w2(100 + t3, b)) : t3 = 60, I[e3] = w2(30 + t3, h), I[M] = w2(40 + t3, b);
+        M = _2(e3), 8 > t3 ? (I[e3 + k] = w2(90 + t3, h), I[M + k] = w2(100 + t3, b)) : t3 = 60, I[e3] = w2(30 + t3, h), I[M] = w2(40 + t3, b);
       })), s2.extend(I);
     }, "e"))();
     module.exports = w, w.default = w;
@@ -966,7 +967,7 @@ var require_range = __commonJS({
             this.set = [first];
           } else if (this.set.length > 1) {
             for (const c of this.set) {
-              if (c.length === 1 && isAny2(c[0])) {
+              if (c.length === 1 && isAny(c[0])) {
                 this.set = [c];
                 break;
               }
@@ -1089,7 +1090,7 @@ var require_range = __commonJS({
     } = require_re();
     var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
     var isNullSet = /* @__PURE__ */ __name((c) => c.value === "<0.0.0-0", "isNullSet");
-    var isAny2 = /* @__PURE__ */ __name((c) => c.value === "", "isAny");
+    var isAny = /* @__PURE__ */ __name((c) => c.value === "", "isAny");
     var isSatisfiable = /* @__PURE__ */ __name((comparators, options) => {
       let result = true;
       const remainingComparators = comparators.slice();
@@ -1121,8 +1122,8 @@ var require_range = __commonJS({
     }, "replaceTildes");
     var replaceTilde = /* @__PURE__ */ __name((comp, options) => {
       const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
-      return comp.replace(r, (_3, M, m, p, pr) => {
-        debug2("tilde", comp, _3, M, m, p, pr);
+      return comp.replace(r, (_2, M, m, p, pr) => {
+        debug2("tilde", comp, _2, M, m, p, pr);
         let ret;
         if (isX(M)) {
           ret = "";
@@ -1147,8 +1148,8 @@ var require_range = __commonJS({
       debug2("caret", comp, options);
       const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
       const z = options.includePrerelease ? "-0" : "";
-      return comp.replace(r, (_3, M, m, p, pr) => {
-        debug2("caret", comp, _3, M, m, p, pr);
+      return comp.replace(r, (_2, M, m, p, pr) => {
+        debug2("caret", comp, _2, M, m, p, pr);
         let ret;
         if (isX(M)) {
           ret = "";
@@ -1979,801 +1980,6 @@ var require_semver2 = __commonJS({
   }
 });
 
-// ../../node_modules/.bun/@sindresorhus+is@7.2.0/node_modules/@sindresorhus/is/distribution/utilities.js
-function keysOf(value) {
-  return Object.keys(value);
-}
-__name(keysOf, "keysOf");
-
-// ../../node_modules/.bun/@sindresorhus+is@7.2.0/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 && tagType !== "Object") {
-    return tagType;
-  }
-  if (hasPromiseApi(value)) {
-    return "Promise";
-  }
-  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,
-  optional: isOptional,
-  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 validatePredicateArray(predicateArray, allowEmpty) {
-  if (predicateArray.length === 0) {
-    if (allowEmpty) ; else {
-      throw new TypeError("Invalid predicate array");
-    }
-    return;
-  }
-  for (const predicate of predicateArray) {
-    if (!isFunction(predicate)) {
-      throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);
-    }
-  }
-}
-__name(validatePredicateArray, "validatePredicateArray");
-function isAll(predicate, ...values) {
-  if (Array.isArray(predicate)) {
-    const predicateArray = predicate;
-    validatePredicateArray(predicateArray, values.length === 0);
-    const combinedPredicate = /* @__PURE__ */ __name((value) => predicateArray.every((singlePredicate) => singlePredicate(value)), "combinedPredicate");
-    if (values.length === 0) {
-      return combinedPredicate;
-    }
-    return predicateOnArray(Array.prototype.every, combinedPredicate, values);
-  }
-  return predicateOnArray(Array.prototype.every, predicate, values);
-}
-__name(isAll, "isAll");
-function isAny(predicate, ...values) {
-  if (Array.isArray(predicate)) {
-    const predicateArray = predicate;
-    validatePredicateArray(predicateArray, values.length === 0);
-    const combinedPredicate = /* @__PURE__ */ __name((value) => predicateArray.some((singlePredicate) => singlePredicate(value)), "combinedPredicate");
-    if (values.length === 0) {
-      return combinedPredicate;
-    }
-    return predicateOnArray(Array.prototype.some, combinedPredicate, values);
-  }
-  return predicateOnArray(Array.prototype.some, predicate, values);
-}
-__name(isAny, "isAny");
-function isOptional(value, predicate) {
-  return isUndefined(value) || predicate(value);
-}
-__name(isOptional, "isOptional");
-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) && /^class(\s+|{)/.test(value.toString());
-}
-__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 (Symbol.observable !== void 0 && 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");
-
-// ../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(
-      (a2, b) => compareMap.get(a2) - compareMap.get(b)
-    );
-  } else {
-    return array.concat().sort(
-      (a2, b) => {
-        if (a2[compareBy] > b[compareBy]) return 1;
-        return b[compareBy] > a2[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 }, (_3, 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");
-function intersection(...arrays) {
-  return arrays.reduce((a2, b) => a2.filter((value) => b.includes(value)));
-}
-__name(intersection, "intersection");
-function pick(obj, keys) {
-  return Object.fromEntries(Object.entries(obj).filter(([key]) => keys.includes(key)));
-}
-__name(pick, "pick");
-function uniq(array) {
-  return Array.from(new Set(array));
-}
-__name(uniq, "uniq");
-function fromPairs(pairs) {
-  return Object.fromEntries(pairs);
-}
-__name(fromPairs, "fromPairs");
-var _ = {
-  keyBy,
-  sortBy,
-  compact,
-  keys: Object.keys,
-  values: Object.values,
-  some: /* @__PURE__ */ __name((a2, fn) => a2.some(fn), "some"),
-  filter,
-  each,
-  castArray,
-  mapValues,
-  times,
-  map,
-  flatMap,
-  intersection,
-  pick,
-  uniq,
-  fromPairs,
-  // type checks
-  isString,
-  isBoolean,
-  isError,
-  isPromise,
-  isFunction,
-  isNan,
-  isNumber,
-  isPlainObject,
-  isArray,
-  isInteger
-};
-var my_dash_default = _;
-
 // ../env-spec-parser/dist/chunk-XRNR4FE7.mjs
 var __defProp = Object.defineProperty;
 var __name2 = /* @__PURE__ */ __name((target, value) => __defProp(target, "name", { value, configurable: true }), "__name");
@@ -7588,142 +6794,6 @@ function parseEnvSpecDotEnvFile(source) {
 __name(parseEnvSpecDotEnvFile, "parseEnvSpecDotEnvFile");
 __name2(parseEnvSpecDotEnvFile, "parseEnvSpecDotEnvFile");
 
-// src/env-graph/lib/errors.ts
-var VarlockError = class extends Error {
-  constructor(errOrMessage, more) {
-    super(my_dash_default.isError(errOrMessage) ? errOrMessage.message : errOrMessage);
-    this.more = more;
-    if (my_dash_default.isError(errOrMessage)) {
-      this.originalError = errOrMessage;
-      this.icon = "\u{1F4A5}";
-    } else {
-      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 location() {
-    return this.more?.location;
-  }
-  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 ConfigLoadError = class extends VarlockError {
-  static {
-    __name(this, "ConfigLoadError");
-  }
-  cleanedStack;
-  constructor(err) {
-    super(err);
-    let stackLines = (err.stack?.split("\n") || []).slice(1);
-    stackLines = stackLines.filter((l) => {
-      if (l.includes(" at ViteNodeRunner.")) return false;
-      if (l.includes("core/src/config-loader/config-loader.ts")) return false;
-      return true;
-    });
-    this.message = `${err.name}: ${err.message}`;
-    this.cleanedStack = stackLines || [];
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      cleanedStack: this.cleanedStack
-    };
-  }
-};
-var ParseError = class extends VarlockError {
-  static {
-    __name(this, "ParseError");
-  }
-  static defaultIcon = "\u{1F635}\u200D\u{1F4AB}";
-};
-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");
-  }
-};
-
 // src/env-graph/lib/data-types.ts
 var EnvGraphDataType = class {
   constructor(def, factory) {
@@ -8086,16 +7156,16 @@ var BaseDataTypes = [
 ];
 
 // ../utils/src/try-catch.ts
-function isPromise2(obj) {
+function isPromise(obj) {
   return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
 }
-__name(isPromise2, "isPromise");
+__name(isPromise, "isPromise");
 async function tryCatch(tryFn, catchFn) {
   try {
     return await tryFn();
   } catch (err) {
     const catchResult = catchFn(err);
-    if (isPromise2(catchResult)) {
+    if (isPromise(catchResult)) {
       await catchResult;
     }
   }
@@ -8501,7 +7571,7 @@ var builtInRootDecorators = [
         dataSource._loadingError = err instanceof SchemaError ? err : new SchemaError(err);
         return;
       }
-      const { ConfigItem: ConfigItem2 } = await import('./config-item-QQUA44LP.js');
+      const { ConfigItem: ConfigItem2 } = await import('./config-item-L25YE5DP.js');
       for (const [key, entry] of Object.entries(entries)) {
         const existsInSchema = key in graph.configSchema;
         if (!existsInSchema && !createMissing) {
@@ -8617,11 +7687,11 @@ function shortSha(sha) {
   return s || void 0;
 }
 __name(shortSha, "shortSha");
-function mapToDeploymentEnvironment(value, map2) {
+function mapToDeploymentEnvironment(value, map) {
   if (!value || typeof value !== "string") return void 0;
   const trimmed = value.trim();
   const key = trimmed.toLowerCase();
-  return map2[key] ?? map2[trimmed];
+  return map[key] ?? map[trimmed];
 }
 __name(mapToDeploymentEnvironment, "mapToDeploymentEnvironment");
 function envEq(name, value) {
@@ -9941,16 +9011,39 @@ function applyBunCryptoShim() {
   }
 }
 __name(applyBunCryptoShim, "applyBunCryptoShim");
-function loadPluginModule(filePath) {
+var isBunRuntime = !!process.versions.bun || false;
+var varlockPluginLibExports = {
+  plugin: pluginProxy,
+  ValidationError,
+  CoercionError,
+  SchemaError,
+  ResolutionError,
+  createDebug
+};
+function loadPluginModuleCJS(filePath) {
   applyBunCryptoShim();
   const code = fs4.readFileSync(filePath, "utf-8");
   const pluginDir = path2.dirname(filePath);
   const moduleObj = { exports: {} };
-  const requireFn = createRequire(filePath);
+  const baseRequire = createRequire(filePath);
+  const requireFn = /* @__PURE__ */ __name((id) => {
+    if (id === "varlock/plugin-lib") return varlockPluginLibExports;
+    return baseRequire(id);
+  }, "requireFn");
+  requireFn.resolve = baseRequire.resolve.bind(baseRequire);
+  requireFn.main = baseRequire.main;
+  requireFn.cache = baseRequire.cache;
   const moduleFn = new Function("exports", "require", "module", "__filename", "__dirname", code);
   moduleFn(moduleObj.exports, requireFn, moduleObj, filePath, pluginDir);
 }
-__name(loadPluginModule, "loadPluginModule");
+__name(loadPluginModuleCJS, "loadPluginModuleCJS");
+async function loadPluginModuleESM(filePath) {
+  {
+    const fileUrl = pathToFileURL(filePath).href;
+    await import(`${fileUrl}?t=${Date.now()}`);
+  }
+}
+__name(loadPluginModuleESM, "loadPluginModuleESM");
 var VarlockPlugin = class {
   static {
     __name(this, "VarlockPlugin");
@@ -10086,23 +9179,54 @@ var VarlockPlugin = class {
     return path2.join(this.localPath, pluginExport);
   }
   async executePluginModule() {
-    globalThis.plugin = this;
+    activatePlugin(this);
+    const hadGlobalPlugin = "plugin" in globalThis;
+    const prevGlobalPlugin = globalThis.plugin;
+    const pluginGlobalRemovedMsg = `[varlock] Plugin "${this.name}" is incompatible with this version of varlock. Please upgrade the plugin to the latest version.`;
+    Object.defineProperty(globalThis, "plugin", {
+      get() {
+        throw new Error(pluginGlobalRemovedMsg);
+      },
+      set() {
+        throw new Error(pluginGlobalRemovedMsg);
+      },
+      configurable: true
+    });
     try {
       if (!await pathExists(this.pluginFilePath)) throw new Error(`Plugin file not found: ${this.pluginFilePath}`);
       importedPluginModulePaths.add(this.pluginFilePath);
-      loadPluginModule(this.pluginFilePath);
+      const ext = path2.extname(this.pluginFilePath).toLowerCase();
+      if (ext === ".mjs" || ext === ".ts") {
+        await loadPluginModuleESM(this.pluginFilePath);
+      } else {
+        loadPluginModuleCJS(this.pluginFilePath);
+      }
     } catch (err) {
       this.loadingError = err;
+    } finally {
+      if (hadGlobalPlugin) {
+        Object.defineProperty(globalThis, "plugin", {
+          value: prevGlobalPlugin,
+          writable: true,
+          configurable: true,
+          enumerable: true
+        });
+      } else {
+        delete globalThis.plugin;
+      }
+      deactivatePlugin();
     }
-    delete globalThis.plugin;
   }
 };
 async function initPluginFromLocalPath(localPath) {
   const stats = await fs2.stat(localPath);
   if (stats.isFile()) {
     const ext = path2.extname(localPath).toLowerCase();
-    if ([".js", ".cjs", ".mjs"].includes(ext) === false) {
-      throw new SchemaError(`Single-file plugin must be a .js, .cjs, or .mjs file: ${localPath}`);
+    if (ext === ".ts" && !isBunRuntime) {
+      throw new SchemaError(`TypeScript plugins (.ts) require Bun \u2014 try renaming to .mjs or compiling to .js first: ${localPath}`);
+    }
+    if (![".js", ".cjs", ".mjs", ".ts"].includes(ext)) {
+      throw new SchemaError(`Single-file plugin must be a .js, .cjs, .mjs, or .ts file: ${localPath}`);
     }
     return new VarlockPlugin({
       type: "single-file",
@@ -10397,8 +9521,8 @@ var EnvGraphDataSource2 = class {
       return keysToImport;
     }
   }
-  /** adds a child data source and sets up the correct references in both directions */
-  async addChild(child, importMeta) {
+  /** shared child-setup logic: wire up parent/graph refs, finishInit (but no import processing) */
+  async _initChild(child, importMeta) {
     if (!this.graph) throw new Error("expected graph to be set");
     this.children.unshift(child);
     child.parent = this;
@@ -10406,6 +9530,11 @@ var EnvGraphDataSource2 = class {
     if (importMeta) child.importMeta = importMeta;
     await child.finishInit();
   }
+  /** adds a child data source, running both finishInit and import processing */
+  async addChild(child, importMeta) {
+    await this._initChild(child, importMeta);
+    await child._processImports();
+  }
   /**
    * Whether this data source is environment-specific.
    * A source is env-specific if:
@@ -10472,6 +9601,13 @@ var EnvGraphDataSource2 = class {
     }
     const disabledDec = this.getRootDec("disable");
     if (disabledDec) {
+      await disabledDec.process();
+      if (disabledDec.decValueResolver) {
+        for (const depKey of disabledDec.decValueResolver.deps) {
+          const depItem = this.graph.configSchema[depKey];
+          if (depItem) await depItem.earlyResolve();
+        }
+      }
       const disabledVal = await disabledDec.resolve();
       if (!my_dash_default.isBoolean(disabledVal)) {
         this._loadingError = new Error("expected @disable to be boolean value");
@@ -10486,6 +9622,16 @@ var EnvGraphDataSource2 = class {
     for (const itemKey of this.importKeys || my_dash_default.keys(this.configItemDefs)) {
       const itemDef = this.configItemDefs[itemKey];
       if (!itemDef) continue;
+      const existingItem = this.graph.configSchema[itemKey];
+      if (existingItem?.isResolved && itemDef.parsedValue !== void 0) {
+        const isMatchingStatic = itemDef.parsedValue instanceof ParsedEnvSpecStaticValue && itemDef.parsedValue.unescapedValue === existingItem.resolvedValue;
+        if (!isMatchingStatic) {
+          this._schemaErrors.push(new SchemaError(
+            `"${itemKey}" was already resolved during early initialization (used by @currentEnv, @import, or @disable) and cannot be redefined by ${this.label}`
+          ));
+          continue;
+        }
+      }
       this.graph.configSchema[itemKey] ??= new ConfigItem(this.graph, itemKey);
     }
     const currentEnvDec = this.getRootDec("currentEnv");
@@ -10538,7 +9684,16 @@ var EnvGraphDataSource2 = class {
     const defaultRequiredDec = this.getRootDec("defaultRequired");
     await defaultRequiredDec?.process();
     await processPluginInstallDecorators(this);
-    if (!this.isValid) return;
+  }
+  /**
+   * Process @import decorators for this data source.
+   * Separated from finishInit() so that DirectoryDataSource can load all
+   * auto-loaded files first, then process imports once values from
+   * .env, .env.local, etc. are available for import conditions.
+   */
+  async _processImports() {
+    if (!this.graph) throw new Error("expected graph to be set");
+    if (!this.isValid || this.disabled) return;
     const importDecs = this.getRootDecFns("import");
     if (importDecs.length) {
       for (const importDec of importDecs) {
@@ -10878,49 +10033,80 @@ var DirectoryDataSource = class extends EnvGraphDataSource2 {
     return `directory - ${this.basePath}`;
   }
   schemaDataSource;
+  /** load a file as a child, running finishInit but NOT processing imports yet */
   async addAutoLoadedFile(fileName) {
     if (!this.graph) throw new Error("expected graph to be set");
     const filePath = path2.join(this.basePath, fileName);
     if (this.graph.virtualImports) {
       if (this.graph.virtualImports[filePath]) {
         const source2 = new DotEnvFileDataSource(filePath, { overrideContents: this.graph.virtualImports[filePath] });
-        await this.addChild(source2);
+        await this._addChildWithoutImports(source2);
         return source2;
       }
       return;
     }
     if (!await pathExists(filePath)) return;
     const source = new DotEnvFileDataSource(filePath);
-    await this.addChild(source);
+    await this._addChildWithoutImports(source);
     return source;
   }
-  async _finishInit() {
+  /** like addChild but skips import processing — used so all files can be loaded before imports run */
+  async _addChildWithoutImports(child) {
+    await this._initChild(child);
+  }
+  /** resolve currentEnv from schema's envFlagKey or parent chain */
+  async _resolveCurrentEnv() {
     if (!this.graph) throw new Error("expected graph to be set");
-    await this.addAutoLoadedFile(".env.schema");
-    await this.addAutoLoadedFile(".env");
-    if (this.children.length) {
-      this.schemaDataSource = this.children[this.children.length - 1];
-    }
-    await this.addAutoLoadedFile(".env.local");
-    let currentEnv;
     if (this.schemaDataSource?._envFlagKey) {
       const envFlagKey = this.schemaDataSource._envFlagKey;
       if (this.isPartialImport && !this.importKeys?.includes(envFlagKey)) {
         this._loadingError = new Error(
           `Imported directory has @currentEnv set to $${envFlagKey}, but "${envFlagKey}" is not included in the import list. Add "${envFlagKey}" to the @import() arguments.`
         );
-        return;
+        return void 0;
       }
       const envFlagItem = this.graph.configSchema[envFlagKey];
       if (envFlagItem) {
         if (!envFlagItem.resolvedValue) await envFlagItem.earlyResolve();
-        currentEnv = envFlagItem.resolvedValue?.toString();
+        return envFlagItem.resolvedValue?.toString();
       }
     }
-    currentEnv ||= (await this.resolveCurrentEnv())?.toString() || this.envFlagValue?.toString();
+    return (await this.resolveCurrentEnv())?.toString() || this.envFlagValue?.toString();
+  }
+  /** load env-specific files (.env.ENV and .env.ENV.local) for the given environment */
+  async _loadEnvSpecificFiles(currentEnv) {
+    const sources = [];
+    const s1 = await this.addAutoLoadedFile(`.env.${currentEnv}`);
+    if (s1) sources.push(s1);
+    const s2 = await this.addAutoLoadedFile(`.env.${currentEnv}.local`);
+    if (s2) sources.push(s2);
+    return sources;
+  }
+  async _finishInit() {
+    if (!this.graph) throw new Error("expected graph to be set");
+    await this.addAutoLoadedFile(".env.schema");
+    await this.addAutoLoadedFile(".env");
+    if (this.children.length) {
+      this.schemaDataSource = this.children[this.children.length - 1];
+    }
+    await this.addAutoLoadedFile(".env.local");
+    let currentEnv = await this._resolveCurrentEnv();
+    if (this._loadingError) return;
     if (currentEnv) {
-      await this.addAutoLoadedFile(`.env.${currentEnv}`);
-      await this.addAutoLoadedFile(`.env.${currentEnv}.local`);
+      await this._loadEnvSpecificFiles(currentEnv);
+    }
+    for (const child of [...this.children].reverse()) {
+      await child._processImports();
+    }
+    if (!currentEnv) {
+      currentEnv = await this._resolveCurrentEnv();
+      if (this._loadingError) return;
+      if (currentEnv) {
+        const envSources = await this._loadEnvSpecificFiles(currentEnv);
+        for (const source of envSources) {
+          await source._processImports();
+        }
+      }
     }
   }
 };
@@ -11269,6 +10455,7 @@ var EnvGraph2 = class {
     this.rootDataSource = source;
     source.graph = this;
     await source.finishInit();
+    await source._processImports();
   }
   async finishLoad() {
     for (const source of this.sortedDataSources) {
@@ -12082,8 +11269,7 @@ var ConfigItem = class {
     };
   }
 };
-//! these are probably not relevant anymore, or needs to move to a plugin layer?
 
-export { CoercionError, ConfigItem, ConfigLoadError, DirectoryDataSource, DotEnvFileDataSource, EnvGraph2 as EnvGraph, FileBasedDataSource, ParsedEnvSpecStaticValue, ResolutionError, SchemaError, ValidationError, VarlockError, ansis_default, detectWorkspaceInfo, envSpecUpdater, getUserVarlockDir, my_dash_default, parseEnvSpecDotEnvFile, pathExists, require_semver2 as require_semver, runWithWorkspaceInfo, tryCatch };
-//# sourceMappingURL=chunk-MXPBXRWY.js.map
-//# sourceMappingURL=chunk-MXPBXRWY.js.map
+export { ConfigItem, DirectoryDataSource, DotEnvFileDataSource, EnvGraph2 as EnvGraph, FileBasedDataSource, ParsedEnvSpecStaticValue, ansis_default, detectWorkspaceInfo, envSpecUpdater, getUserVarlockDir, parseEnvSpecDotEnvFile, pathExists, require_semver2 as require_semver, runWithWorkspaceInfo, tryCatch };
+//# sourceMappingURL=chunk-CU6IMJWG.js.map
+//# sourceMappingURL=chunk-CU6IMJWG.js.map