varlock 0.3.0 → 0.4.0

package/dist/{chunk-WZW7QS6M.js → chunk-CBP4M7BN.js}

@@ -6,8 +6,11 @@ import os from 'os';
 import fs3, { accessSync } 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 vm from 'vm';
 
 // ../../node_modules/.bun/semver@7.7.4/node_modules/semver/internal/constants.js
 var require_constants = __commonJS({
@@ -8353,7 +8356,7 @@ var builtInRootDecorators = [
         dataSource._loadingError = err instanceof SchemaError ? err : new SchemaError(err);
         return;
       }
-      const { ConfigItem: ConfigItem3 } = await import('./config-item-2AL7WF23.js');
+      const { ConfigItem: ConfigItem2 } = await import('./config-item-GN5AUR45.js');
       for (const [key, entry] of Object.entries(entries)) {
         const existsInSchema = key in graph.configSchema;
         if (!existsInSchema && !createMissing) {
@@ -8369,7 +8372,7 @@ var builtInRootDecorators = [
           };
         }
         if (!existsInSchema && createMissing) {
-          const newItem = new ConfigItem3(graph, key);
+          const newItem = new ConfigItem2(graph, key);
           graph.configSchema[key] = newItem;
           await newItem.process();
         }
@@ -9568,6 +9571,53 @@ __name(convertParsedValueToResolvers, "convertParsedValueToResolvers");
 
 // src/env-graph/lib/plugins.ts
 var importedPluginModulePaths = /* @__PURE__ */ new Set();
+function isSEABuild() {
+  try {
+    return false;
+  } catch {
+    return false;
+  }
+}
+__name(isSEABuild, "isSEABuild");
+async function loadPluginModuleInSEA(filePath) {
+  const code = fs3.readFileSync(filePath, "utf-8");
+  const fileUrl = pathToFileURL(filePath).href;
+  const pluginDir = path.dirname(filePath);
+  const pluginRequire = createRequire(filePath);
+  let transformed = code.replace(
+    /^import\s+(\w+)\s*,\s*(\{[^}]+\})\s+from\s+['"]([^'"]+)['"]\s*;?/gm,
+    'const $1 = __plugin_require__("$3"); const $2 = $1;'
+  ).replace(
+    /^import\s+\*\s+as\s+(\w+)\s+from\s+['"]([^'"]+)['"]\s*;?/gm,
+    'const $1 = __plugin_require__("$2");'
+  ).replace(
+    /^import\s+(\{[^}]+\})\s+from\s+['"]([^'"]+)['"]\s*;?/gm,
+    'const $1 = __plugin_require__("$2");'
+  ).replace(
+    /^import\s+(\w+)\s+from\s+['"]([^'"]+)['"]\s*;?/gm,
+    'const $1 = __plugin_require__("$2");'
+  ).replace(
+    /^import\s+['"]([^'"]+)['"]\s*;?/gm,
+    '__plugin_require__("$1");'
+  );
+  transformed = transformed.replace(/import\.meta/g, "__plugin_import_meta__");
+  const wrapped = `(async () => {
+${transformed}
+})()`;
+  const context = vm.createContext(globalThis, {
+    codeGeneration: { strings: true, wasm: true }
+  });
+  context.__plugin_require__ = pluginRequire;
+  context.__plugin_import_meta__ = Object.freeze({
+    url: fileUrl,
+    dirname: pluginDir,
+    filename: filePath
+  });
+  const script = new vm.Script(wrapped, { filename: filePath });
+  const result = script.runInContext(context);
+  await result;
+}
+__name(loadPluginModuleInSEA, "loadPluginModuleInSEA");
 var VarlockPlugin = class {
   static {
     __name(this, "VarlockPlugin");
@@ -9654,7 +9704,11 @@ var VarlockPlugin = class {
     try {
       if (!await pathExists(this.pluginFilePath)) throw new Error(`Plugin file not found: ${this.pluginFilePath}`);
       importedPluginModulePaths.add(this.pluginFilePath);
-      await import(this.pluginFilePath);
+      if (isSEABuild()) {
+        await loadPluginModuleInSEA(this.pluginFilePath);
+      } else {
+        await import(this.pluginFilePath);
+      }
     } catch (err) {
       this.loadingError = err;
     }
@@ -9970,6 +10024,28 @@ var EnvGraphDataSource2 = class {
     if (importMeta) child.importMeta = importMeta;
     await child.finishInit();
   }
+  /**
+   * Whether this data source is environment-specific.
+   * A source is env-specific if:
+   * - it was auto-loaded for a specific env (e.g., `.env.production` loaded by a DirectoryDataSource)
+   * - it has a conditional `@disable` decorator (e.g., `@disable=forEnv(test)`)
+   * - it was conditionally imported (e.g., `@import(..., enabled=forEnv("dev"))`)
+   * - any of its ancestors are env-specific
+   * Used by type generation to filter out env-dependent definitions.
+   *
+   * Note: `applyForEnv` from filename parsing is only relevant for auto-loaded files.
+   * Explicitly imported files (via `@import`) are controlled by the import mechanism,
+   * not the auto-load-by-env logic, so their `applyForEnv` is ignored here.
+   */
+  get isEnvSpecific() {
+    if (this.applyForEnv && !this.isImport) return true;
+    if (this._hasConditionalDisable) return true;
+    if (this.importMeta?.isConditionallyEnabled) return true;
+    if (this.parent?.isEnvSpecific) return true;
+    return false;
+  }
+  /** true when the source has a `@disable` decorator whose value is not static */
+  _hasConditionalDisable;
   /** environment flag key (as set by @envFlag decorator) - only if set within this source */
   _envFlagKey;
   /** environment flag key getter that will follow up the parent chain */
@@ -10019,6 +10095,9 @@ var EnvGraphDataSource2 = class {
         return;
       }
       this._disabled = disabledVal;
+      if (disabledDec.decValueResolver && !disabledDec.decValueResolver.isStatic) {
+        this._hasConditionalDisable = true;
+      }
     }
     if (this.disabled) return;
     for (const itemKey of this.importKeys || my_dash_default.keys(this.configItemDefs)) {
@@ -10083,8 +10162,8 @@ var EnvGraphDataSource2 = class {
         try {
           await importDec.process();
           if (importDec.decValueResolver?.objArgs?.enabled) {
-            const enabledResolver = importDec.decValueResolver.objArgs.enabled;
-            const enabledDeps = enabledResolver.deps;
+            const enabledResolver2 = importDec.decValueResolver.objArgs.enabled;
+            const enabledDeps = enabledResolver2.deps;
             for (const depKey of enabledDeps) {
               const depItem = this.graph.configSchema[depKey];
               if (!depItem) {
@@ -10115,6 +10194,8 @@ var EnvGraphDataSource2 = class {
             throw new Error("expected @import enabled parameter to be a boolean");
           }
           if (!enabledValue) continue;
+          const enabledResolver = importDec.decValueResolver?.objArgs?.enabled;
+          const isConditionallyEnabled = !!enabledResolver && !enabledResolver.isStatic;
           const allowMissing = importArgs.obj.allowMissing ?? false;
           if (!my_dash_default.isBoolean(allowMissing)) {
             throw new Error("expected @import allowMissing parameter to be a boolean");
@@ -10131,7 +10212,8 @@ var EnvGraphDataSource2 = class {
                 }
                 await this.addChild(new DirectoryDataSource(fullImportPath), {
                   isImport: true,
-                  importKeys
+                  importKeys,
+                  isConditionallyEnabled
                 });
               } else {
                 const fileExists = this.graph.virtualImports[fullImportPath];
@@ -10143,7 +10225,7 @@ var EnvGraphDataSource2 = class {
                 const source = new DotEnvFileDataSource(fullImportPath, {
                   overrideContents: this.graph.virtualImports[fullImportPath]
                 });
-                await this.addChild(source, { isImport: true, importKeys });
+                await this.addChild(source, { isImport: true, importKeys, isConditionallyEnabled });
               }
             } else {
               const fsStat = await tryCatch(async () => fs.stat(fullImportPath), (_err) => {
@@ -10157,7 +10239,8 @@ var EnvGraphDataSource2 = class {
                 if (fsStat.isDirectory()) {
                   await this.addChild(new DirectoryDataSource(fullImportPath), {
                     isImport: true,
-                    importKeys
+                    importKeys,
+                    isConditionallyEnabled
                   });
                 } else {
                   this._loadingError = new Error(`Imported path ending with "/" is not a directory: ${fullImportPath}`);
@@ -10171,7 +10254,11 @@ var EnvGraphDataSource2 = class {
                   this._loadingError = new Error("imported file must be a .env.* file");
                   return;
                 }
-                await this.addChild(new DotEnvFileDataSource(fullImportPath), { isImport: true, importKeys });
+                await this.addChild(new DotEnvFileDataSource(fullImportPath), {
+                  isImport: true,
+                  importKeys,
+                  isConditionallyEnabled
+                });
               }
             }
           } else if (importPath.startsWith("http://") || importPath.startsWith("https://")) {
@@ -10501,18 +10588,18 @@ async function fetchIconSvg(iconifyName, color = "808080", iconCacheFolder = "/t
   return colorizedSvg;
 }
 __name(fetchIconSvg, "fetchIconSvg");
-async function getTsDefinitionForItem(item, indentLevel = 0) {
+async function getTsDefinitionForItem(info, 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;
+  jsDocLines.push(`**${info.key}**${info.isSensitive ? " \u{1F510} _sensitive_" : ""}`);
+  if (info.description) jsDocLines.push(...info.description.split("\n"));
+  const iconName = info.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;
+  const docsLinks = info.docsLinks;
   if (docsLinks.length) {
     jsDocLines.push("");
     docsLinks.forEach((docsEntry) => {
@@ -10530,7 +10617,7 @@ async function getTsDefinitionForItem(item, indentLevel = 0) {
       " */"
     ]);
   }
-  const dataType = item.dataType;
+  const dataType = info.dataType;
   const dataTypeName = dataType?.name;
   let itemTsType = "string";
   if (dataType) {
@@ -10551,24 +10638,25 @@ async function getTsDefinitionForItem(item, indentLevel = 0) {
       }
     }
   }
-  const isRequired = item.isRequired && !item.isRequiredDynamic;
-  itemSrc.push(`${item.key}${isRequired ? "" : "?"}: ${itemTsType};`);
+  const isRequired = info.isRequired && !info.isRequiredDynamic;
+  itemSrc.push(`${info.key}${isRequired ? "" : "?"}: ${itemTsType};`);
   itemSrc.push("");
   return my_dash_default.map(itemSrc, (line) => `${i}${line}`);
 }
 __name(getTsDefinitionForItem, "getTsDefinitionForItem");
-async function generateTsTypesSrc(graph) {
+async function generateTsTypesSrc(items) {
   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 exposedKeys = [];
   const exposedNonSensitiveKeys = [];
-  for (const itemKey of graph.sortedConfigKeys) {
-    const configItem = graph.configSchema[itemKey];
-    tsSrc.push(...await getTsDefinitionForItem(configItem, 1));
-    if (!configItem.isSensitive) exposedNonSensitiveKeys.push(itemKey);
+  for (const info of items) {
+    tsSrc.push(...await getTsDefinitionForItem(info, 1));
+    exposedKeys.push(info.key);
+    if (!info.isSensitive) exposedNonSensitiveKeys.push(info.key);
   }
   tsSrc.push("};\n");
   tsSrc.push(`
@@ -10606,7 +10694,13 @@ export type EnvSchemaAsStrings = {
 __name(generateTsTypesSrc, "generateTsTypesSrc");
 async function generateTypes(graph, lang, typesPath) {
   if (lang !== "ts") throw new Error(`Unsupported @generateTypes lang: ${lang}`);
-  const tsSrc = await generateTsTypesSrc(graph);
+  const items = [];
+  for (const itemKey of graph.sortedConfigKeys) {
+    const configItem = graph.configSchema[itemKey];
+    if (!configItem.defsForTypeGeneration.length) continue;
+    items.push(await configItem.getTypeGenInfo());
+  }
+  const tsSrc = await generateTsTypesSrc(items);
   await fs3.promises.writeFile(typesPath, tsSrc, "utf-8");
 }
 __name(generateTypes, "generateTypes");
@@ -10614,7 +10708,7 @@ __name(generateTypes, "generateTypes");
 // src/env-graph/lib/env-graph.ts
 var processExists = !!globalThis.process;
 var originalProcessEnv = { ...processExists && process.env };
-var EnvGraph3 = class {
+var EnvGraph2 = class {
   static {
     __name(this, "EnvGraph");
   }
@@ -10916,6 +11010,33 @@ var EnvGraph3 = class {
   async generateTypes(lang, outputPath) {
     await generateTypes(this, lang, outputPath);
   }
+  /**
+   * Resolve @generateTypes decorators and generate type files.
+   * This should be called after finishLoad() but before resolveEnvValues().
+   * The @generateTypes decorator args (lang, path) are static, so we can resolve them
+   * without needing full env resolution. Type info is computed from non-env-specific
+   * definitions only, so the output is deterministic regardless of environment.
+   *
+   * @param opts.ignoreAutoFalse - if true, generate types even if `auto=false` is set.
+   *   Used by the `varlock typegen` command to force generation.
+   */
+  async generateTypesIfNeeded(opts) {
+    const generateTypesDecs = this.getRootDecFns("generateTypes");
+    let generatedCount = 0;
+    for (const generateTypesDec of generateTypesDecs) {
+      const typeGenSettings = await generateTypesDec.resolve();
+      if (generateTypesDec.dataSource.isImport && !typeGenSettings.obj.executeWhenImported) continue;
+      if (typeGenSettings.obj.auto === false && !opts?.ignoreAutoFalse) continue;
+      if (!typeGenSettings.obj.lang) throw new Error("@generateTypes - must set `lang` arg");
+      if (typeGenSettings.obj.lang !== "ts") throw new Error(`@generateTypes - unsupported language: ${typeGenSettings.obj.lang}`);
+      if (!typeGenSettings.obj.path) throw new Error("@generateTypes - must set `path` arg");
+      if (!my_dash_default.isString(typeGenSettings.obj.path)) throw new Error("@generateTypes - `path` arg must be a string");
+      const outputPath = generateTypesDec.dataSource instanceof FileBasedDataSource ? path.resolve(generateTypesDec.dataSource.fullPath, "..", typeGenSettings.obj.path) : typeGenSettings.obj.path;
+      await this.generateTypes(typeGenSettings.obj.lang, outputPath);
+      generatedCount++;
+    }
+    return generatedCount;
+  }
   getRootDec(decoratorName) {
     const sources = Array.from(this.sortedDataSources).reverse();
     for (const s of sources) {
@@ -10968,6 +11089,14 @@ var ConfigItem = class {
     defs.push(...this._internalDefs);
     return defs;
   }
+  /**
+   * Like `defs` but filtered to exclude environment-specific data sources.
+   * Used by type generation so that generated types are deterministic
+   * regardless of which environment is being loaded.
+   */
+  get defsForTypeGeneration() {
+    return this.defs.filter((def) => !def.source || !def.source.isEnvSpecific);
+  }
   get description() {
     for (const def of this.defs) {
       if (def.itemDef.description) return def.itemDef.description;
@@ -11363,9 +11492,167 @@ var ConfigItem = class {
   get isValid() {
     return this.validationState === "valid";
   }
+  /**
+   * Compute schema-level info for type generation using only non-env-specific definitions.
+   * This mirrors the logic of processRequired/processSensitive but:
+   * - Uses defsForTypeGeneration (excludes env-specific sources)
+   * - Returns a result object instead of mutating item state
+   * - Resolves only static decorators from non-env-specific sources
+   */
+  async getTypeGenInfo() {
+    const defs = this.defsForTypeGeneration;
+    let description;
+    for (const def of defs) {
+      if (def.itemDef.description) {
+        description = def.itemDef.description;
+        break;
+      }
+    }
+    let isRequired = true;
+    let isRequiredDynamic = false;
+    try {
+      for (const def of defs) {
+        const requiredDecs = def.itemDef.decorators?.filter((d) => d.name === "required" || d.name === "optional") || [];
+        const requiredDec = requiredDecs[0];
+        if (requiredDec) {
+          const usingOptional = requiredDec.name === "optional";
+          if (requiredDec.decValueResolver?.fnName !== "\0static") {
+            isRequiredDynamic = true;
+          }
+          const requiredDecoratorVal = await requiredDec.resolve();
+          if (requiredDec.schemaErrors.length) {
+            isRequired = false;
+            break;
+          }
+          if (![true, false, void 0].includes(requiredDecoratorVal)) break;
+          if (requiredDecoratorVal !== void 0) {
+            isRequired = usingOptional ? !requiredDecoratorVal : requiredDecoratorVal;
+            break;
+          }
+        }
+        const defaultRequiredDec = def.source?.getRootDec("defaultRequired");
+        if (defaultRequiredDec) {
+          const defaultRequiredVal = await defaultRequiredDec.resolve();
+          if (my_dash_default.isBoolean(defaultRequiredVal)) {
+            isRequired = defaultRequiredVal;
+            break;
+          } else if (defaultRequiredVal === "infer") {
+            if (def.itemDef.resolver) {
+              if (def.itemDef.resolver instanceof StaticValueResolver) {
+                isRequired = def.itemDef.resolver.staticValue !== void 0 && def.itemDef.resolver.staticValue !== "";
+              } else {
+                isRequired = true;
+              }
+            } else {
+              isRequired = false;
+            }
+            break;
+          }
+        }
+      }
+    } catch {
+    }
+    let isSensitive = true;
+    const sensitiveFromDataType = this.dataType?.isSensitive;
+    try {
+      let foundSensitive = false;
+      for (const def of defs) {
+        const sensitiveDecs = def.itemDef.decorators?.filter((d) => d.name === "sensitive" || d.name === "public") || [];
+        const sensitiveDec = sensitiveDecs[0];
+        if (sensitiveDec) {
+          const usingPublic = sensitiveDec.name === "public";
+          const sensitiveDecValue = await sensitiveDec.resolve();
+          if (sensitiveDec.schemaErrors.length) break;
+          if (![true, false, void 0].includes(sensitiveDecValue)) break;
+          if (sensitiveDecValue !== void 0) {
+            isSensitive = usingPublic ? !sensitiveDecValue : sensitiveDecValue;
+            foundSensitive = true;
+            break;
+          }
+        }
+        if (sensitiveFromDataType !== void 0) continue;
+        const defaultSensitiveDec = def.source?.getRootDec("defaultSensitive");
+        if (defaultSensitiveDec) {
+          if (!defaultSensitiveDec.decValueResolver) break;
+          if (defaultSensitiveDec.decValueResolver.fnName === "inferFromPrefix") {
+            const prefix = defaultSensitiveDec.decValueResolver.arrArgs[0].staticValue;
+            if (my_dash_default.isString(prefix)) {
+              isSensitive = !this.key.startsWith(prefix);
+              foundSensitive = true;
+              break;
+            }
+          } else {
+            const defaultSensitiveVal = await defaultSensitiveDec.resolve();
+            if (my_dash_default.isBoolean(defaultSensitiveVal)) {
+              isSensitive = defaultSensitiveVal;
+              foundSensitive = true;
+              break;
+            }
+          }
+        }
+      }
+      if (!foundSensitive && sensitiveFromDataType !== void 0) {
+        isSensitive = sensitiveFromDataType;
+      }
+    } catch {
+    }
+    let icon;
+    for (const def of defs) {
+      const iconDec = def.itemDef.decorators?.find((d) => d.name === "icon");
+      if (iconDec) {
+        try {
+          icon = await iconDec.resolve();
+        } catch {
+        }
+        break;
+      }
+    }
+    icon ??= this.dataType?.icon;
+    const docsLinks = [];
+    if (this.dataType?.docsEntries) {
+      for (const entry of this.dataType.docsEntries) {
+        if (my_dash_default.isPlainObject(entry)) docsLinks.push(entry);
+        else docsLinks.push({ url: entry });
+      }
+    }
+    for (const def of defs) {
+      const docsUrlDec = def.itemDef.decorators?.find((d) => d.name === "docsUrl");
+      if (docsUrlDec) {
+        try {
+          const val = await docsUrlDec.resolve();
+          if (val) docsLinks.push({ url: val });
+        } catch {
+        }
+      }
+      const docsFnDecs = def.itemDef.decorators?.filter((d) => d.name === "docs" && d.isFunctionCall) || [];
+      for (const docsDec of docsFnDecs) {
+        try {
+          const decVal = await docsDec.resolve();
+          if (decVal?.arr && my_dash_default.isArray(decVal.arr)) {
+            if (decVal.arr.length === 1) {
+              docsLinks.push({ url: decVal.arr[0] });
+            } else if (decVal.arr.length === 2) {
+              docsLinks.push({ url: decVal.arr[1], description: decVal.arr[0] });
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    return {
+      key: this.key,
+      description,
+      dataType: this.dataType,
+      isRequired,
+      isRequiredDynamic,
+      isSensitive,
+      icon,
+      docsLinks
+    };
+  }
 };
 //! these are probably not relevant anymore, or needs to move to a plugin layer?
 
-export { CoercionError, ConfigItem, ConfigLoadError, DirectoryDataSource, DotEnvFileDataSource, EnvGraph3 as EnvGraph, FileBasedDataSource, ParsedEnvSpecStaticValue, ResolutionError, SchemaError, ValidationError, VarlockError, envSpecUpdater, my_dash_default, parseEnvSpecDotEnvFile, pathExists, pathExistsSync, tryCatch };
-//# sourceMappingURL=chunk-WZW7QS6M.js.map
-//# sourceMappingURL=chunk-WZW7QS6M.js.map
+export { CoercionError, ConfigItem, ConfigLoadError, DirectoryDataSource, DotEnvFileDataSource, EnvGraph2 as EnvGraph, ParsedEnvSpecStaticValue, ResolutionError, SchemaError, ValidationError, VarlockError, envSpecUpdater, my_dash_default, parseEnvSpecDotEnvFile, pathExists, pathExistsSync, tryCatch };
+//# sourceMappingURL=chunk-CBP4M7BN.js.map
+//# sourceMappingURL=chunk-CBP4M7BN.js.map