@varlock/nextjs-integration 1.0.1 → 1.1.0

package/dist/next-env-compat.js

@@ -2,7 +2,7 @@
 
 var os = require('os');
 var path3 = require('path');
-var fs32 = require('fs');
+var fs5 = require('fs');
 var util = require('util');
 var P2 = require('process');
 var _ = require('readline');
@@ -41,7 +41,7 @@ function _interopNamespace(e) {
 
 var os__default = /*#__PURE__*/_interopDefault(os);
 var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
-var fs32__namespace = /*#__PURE__*/_interopNamespace(fs32);
+var fs5__namespace = /*#__PURE__*/_interopNamespace(fs5);
 var P2__default = /*#__PURE__*/_interopDefault(P2);
 var ___namespace = /*#__PURE__*/_interopNamespace(_);
 var fs3__default = /*#__PURE__*/_interopDefault(fs3);
@@ -98,15 +98,31 @@ function getUserVarlockDir() {
     return path3.join(process.env.XDG_CONFIG_HOME, "varlock");
   }
   const legacyDir = path3.join(home, ".varlock");
-  if (fs32.existsSync(legacyDir)) {
+  if (fs5.existsSync(legacyDir)) {
     return legacyDir;
   }
   return path3.join(home, ".config", "varlock");
 }
-var init_chunk_7WB7HK5Z = __esm({
-  "../../varlock/dist/chunk-7WB7HK5Z.js"() {
+function isWSL() {
+  if (_isWSL !== void 0) return _isWSL;
+  if (process.env.WSL_DISTRO_NAME) {
+    _isWSL = true;
+    return true;
+  }
+  try {
+    const version = fs5__namespace.default.readFileSync("/proc/version", "utf-8");
+    _isWSL = /microsoft|wsl/i.test(version);
+  } catch {
+    _isWSL = false;
+  }
+  return _isWSL;
+}
+var _isWSL;
+var init_chunk_O3WTD6L4 = __esm({
+  "../../varlock/dist/chunk-O3WTD6L4.js"() {
     init_chunk_6PEHRAEP();
     __name(getUserVarlockDir, "getUserVarlockDir");
+    __name(isWSL, "isWSL");
   }
 });
 function wrapAnsi(string, columns, options) {
@@ -1780,10 +1796,10 @@ ${o}
         if (s === "") return [];
         try {
           let r;
-          fs32.existsSync(s) ? fs32.lstatSync(s).isDirectory() && (!e.directory || s.endsWith("/")) ? r = s : r = path3.dirname(s) : r = path3.dirname(s);
+          fs5.existsSync(s) ? fs5.lstatSync(s).isDirectory() && (!e.directory || s.endsWith("/")) ? r = s : r = path3.dirname(s) : r = path3.dirname(s);
           const u2 = s.length > 1 && s.endsWith("/") ? s.slice(0, -1) : s;
-          return fs32.readdirSync(r).map((n) => {
-            const o = path3.join(r, n), c2 = fs32.lstatSync(o);
+          return fs5.readdirSync(r).map((n) => {
+            const o = path3.join(r, n), c2 = fs5.lstatSync(o);
             return { name: n, path: o, isDirectory: c2.isDirectory() };
           }).filter(({ path: n, isDirectory: o }) => n.startsWith(u2) && (o || !e.directory)).map((n) => ({ value: n.path }));
         } catch {
@@ -3162,15 +3178,15 @@ var init_dist_WGIHRGBZ = __esm({
   }
 });
 
-// ../../varlock/dist/config-item-2FQ6I6PO.js
-var config_item_2FQ6I6PO_exports = {};
-__export(config_item_2FQ6I6PO_exports, {
+// ../../varlock/dist/config-item-6LTV4PNH.js
+var config_item_6LTV4PNH_exports = {};
+__export(config_item_6LTV4PNH_exports, {
   ConfigItem: () => ConfigItem
 });
-var init_config_item_2FQ6I6PO = __esm({
-  "../../varlock/dist/config-item-2FQ6I6PO.js"() {
-    init_chunk_U7RQPX5K();
-    init_chunk_7WB7HK5Z();
+var init_config_item_6LTV4PNH = __esm({
+  "../../varlock/dist/config-item-6LTV4PNH.js"() {
+    init_chunk_XWYFSG46();
+    init_chunk_O3WTD6L4();
     init_chunk_HDKXXS2X();
     init_chunk_2PFIYNFA();
     init_chunk_6PEHRAEP();
@@ -7504,15 +7520,15 @@ function findGraphCycles(graph) {
 }
 async function fetchIconSvg(iconifyName, color = "808080", iconCacheFolder = "/tmp/varlock-icon-cache") {
   if (!iconCacheFolderInit) {
-    fs32__namespace.default.mkdirSync(iconCacheFolder, { recursive: true });
+    fs5__namespace.default.mkdirSync(iconCacheFolder, { recursive: true });
     iconCacheFolderInit = true;
   }
   const iconPath = `${iconCacheFolder}/${iconifyName}-${ICON_SIZE}.svg`;
   let svgSrc;
   if (iconInMemoryCache[iconPath]) {
     svgSrc = iconInMemoryCache[iconPath];
-  } else if (fs32__namespace.default.existsSync(iconPath)) {
-    const svgFileBuffer = await fs32__namespace.default.promises.readFile(iconPath, "utf-8");
+  } else if (fs5__namespace.default.existsSync(iconPath)) {
+    const svgFileBuffer = await fs5__namespace.default.promises.readFile(iconPath, "utf-8");
     svgSrc = svgFileBuffer.toString();
     iconInMemoryCache[iconPath] = svgSrc;
   } else {
@@ -7524,7 +7540,7 @@ async function fetchIconSvg(iconifyName, color = "808080", iconCacheFolder = "/t
     }
     if (!svgSrc) return;
     if (svgSrc) {
-      await fs32__namespace.default.promises.writeFile(iconPath, svgSrc, "utf-8");
+      await fs5__namespace.default.promises.writeFile(iconPath, svgSrc, "utf-8");
       iconInMemoryCache[iconPath] = svgSrc;
     }
   }
@@ -7566,6 +7582,10 @@ async function getTsDefinitionForItem(info, indentLevel = 0) {
       jsDocLines.push(`\u{1F4DA} {@link ${docsLink}}`);
     });
   }
+  if (info.isDeprecated) {
+    jsDocLines.push("");
+    jsDocLines.push(info.deprecationMessage ? `@deprecated ${info.deprecationMessage}` : "@deprecated");
+  }
   if (jsDocLines.length === 1) {
     itemSrc.push(`/** ${jsDocLines[0]} */`);
   } else if (jsDocLines.length > 1) {
@@ -7645,7 +7665,7 @@ async function generateTypes(graph, lang, typesPath) {
     items.push(await configItem.getTypeGenInfo());
   }
   const tsSrc = await generateTsTypesSrc(items);
-  await fs32__namespace.default.promises.writeFile(typesPath, tsSrc, "utf-8");
+  await fs5__namespace.default.promises.writeFile(typesPath, tsSrc, "utf-8");
 }
 function getErrorLocation(source, parserNode) {
   if (!(source instanceof FileBasedDataSource)) return;
@@ -7905,7 +7925,7 @@ async function pathExists(p2) {
 }
 function pathExistsSync(p2) {
   try {
-    fs32.accessSync(p2);
+    fs5.accessSync(p2);
     return true;
   } catch {
     return false;
@@ -7996,7 +8016,7 @@ function detectWorkspaceInfo(opts) {
   const rootPackageJsonPath = path3__namespace.default.join(foundRootPath, "package.json");
   if (pathExistsSync(rootPackageJsonPath)) {
     try {
-      const packageJson = JSON.parse(fs32__namespace.default.readFileSync(rootPackageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(fs5__namespace.default.readFileSync(rootPackageJsonPath, "utf-8"));
       if (packageJson.workspaces) isMonorepo = true;
     } catch {
     }
@@ -8053,7 +8073,7 @@ function applyBunCryptoShim() {
 }
 function loadPluginModuleCJS(filePath) {
   applyBunCryptoShim();
-  const code = fs32__namespace.default.readFileSync(filePath, "utf-8");
+  const code = fs5__namespace.default.readFileSync(filePath, "utf-8");
   const pluginDir = path3__namespace.default.dirname(filePath);
   const moduleObj = { exports: {} };
   const baseRequire = module$1.createRequire(filePath);
@@ -8184,7 +8204,7 @@ async function downloadPlugin(url) {
   }
   const tmpTgz = path3__namespace.default.join(cacheDir, `tmp-${crypto2__default.default.randomBytes(8).toString("hex")}.tgz`);
   await new Promise((resolve2, reject) => {
-    const file = fs32__namespace.default.createWriteStream(tmpTgz);
+    const file = fs5__namespace.default.createWriteStream(tmpTgz);
     https__default.default.get(url, (res) => {
       if (res.statusCode !== 200) {
         reject(new Error(`Failed to download plugin: ${res.statusCode}`));
@@ -8515,9 +8535,9 @@ function coerceToNumber(rawVal) {
   return numVal;
 }
 var require_ansis, require_constants, require_debug, require_re, require_parse_options, require_identifiers, require_semver, require_parse, require_valid, require_clean, require_inc, require_diff, require_major, require_minor, require_patch, require_prerelease, require_compare, require_rcompare, require_compare_loose, require_compare_build, require_sort, require_rsort, require_gt, require_lt, require_eq, require_neq, require_gte, require_lte, require_cmp, require_coerce, require_lrucache, require_range, require_comparator, require_satisfies, require_to_comparators, require_max_satisfying, require_min_satisfying, require_min_version, require_valid2, require_outside, require_gtr, require_ltr, require_intersects, require_simplify, require_subset, require_semver2, __defProp3, __name2, VALID_NUMBER_REGEX, ParsedEnvSpecDivider, ParsedEnvSpecStaticValue, ParsedEnvSpecKeyValuePair, ParsedEnvSpecFunctionArgs, ParsedEnvSpecFunctionCall, ParsedEnvSpecDecorator, ParsedEnvSpecComment, ParsedEnvSpecDecoratorComment, ParsedEnvSpecCommentBlock, ParsedEnvSpecBlankLine, ParsedEnvSpecConfigItem, ParsedEnvSpecFile, EXPAND_VAR_BRACKETED_REGEX, EXPAND_VAR_SIMPLE_REGEX, EXPAND_EXEC_REGEX, peg$SyntaxError, SimpleQueue, AUTOGENERATED_FILE_BANNER, ICON_SIZE, iconCacheFolderInit, iconInMemoryCache, PLATFORMS, VALID_ENVIRONMENTS, ExecError, asyncExec, BUILTIN_VARS, processExists2, originalProcessEnv2, EnvGraph, import_index, ansis_default, Ansis, fg, bg, rgb, bgRgb, hex, bgHex, reset, inverse, hidden, visible, bold, dim, italic, underline, strikethrough, black, red, green, yellow, blue, magenta, cyan, white, gray, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bgGray, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright, import_semver, unicode, unicodeOr, S_STEP_ACTIVE, S_STEP_CANCEL, S_STEP_ERROR, S_STEP_SUBMIT, S_BAR, S_BAR_END, S_RADIO_ACTIVE, S_RADIO_INACTIVE, S_CHECKBOX_ACTIVE, S_CHECKBOX_SELECTED, S_CHECKBOX_INACTIVE, S_PASSWORD_MASK, symbol, limitOptions, confirm, select, multiselect, password, prompts, prompts_default, debug2, JS_PACKAGE_MANAGERS, workspaceInfoStorage, importedPluginModulePaths, _cryptoShimApplied, isBunRuntime, varlockPluginLibExports, VarlockPlugin, DATA_SOURCE_TYPES, EnvGraphDataSource2, ImportAliasSource, FileBasedDataSource, DotEnvFileDataSource, DirectoryDataSource, MultiplePathsContainerDataSource, DecoratorInstance, ItemDecoratorInstance, RootDecoratorInstance2, builtInRootDecorators, builtInItemDecorators, execAsync, REGEX_LIKE_STRING, Resolver, StaticValueResolver, FunctionArgsResolver, ErrorResolver, ConcatResolver, FallbackResolver, execQueue, ExecResolver, RefResolver, RegexResolver, RemapResolver, ForEnvResolver, EqResolver, IfResolver, IfsResolver, NotResolver, IsEmptyResolver, InferFromPrefixResolver, BaseResolvers, EnvGraphDataType, StringDataType, NumberDataType, BooleanDataType, UrlDataType, SimpleObjectDataType, EnumDataType, EMAIL_REGEX, EmailDataType, IP_V4_ADDRESS_REGEX, IP_V6_ADDRESS_REGEX, IpAddressDataType, PortDataType, SEMVER_REGEX, SemverDataType, ISO_DATE_REGEX, IsoDateDataType, UUID_REGEX, UuidDataType, MD5_REGEX, Md5DataType, BaseDataTypes, ConfigItem;
-var init_chunk_U7RQPX5K = __esm({
-  "../../varlock/dist/chunk-U7RQPX5K.js"() {
-    init_chunk_7WB7HK5Z();
+var init_chunk_XWYFSG46 = __esm({
+  "../../varlock/dist/chunk-XWYFSG46.js"() {
+    init_chunk_O3WTD6L4();
     init_chunk_HDKXXS2X();
     init_chunk_2PFIYNFA();
     init_chunk_6PEHRAEP();
@@ -12134,7 +12154,7 @@ ${ansis_default.cyan(S_BAR_END)}
     password = /* @__PURE__ */ __name(async (opts) => {
       return enqueuePasswordPrompt(async () => {
         const mask = opts.mask ?? S_PASSWORD_MASK;
-        if (process.platform === "win32") {
+        if (process.platform === "win32" || isWSL()) {
           const { password: clackPassword, isCancel } = await Promise.resolve().then(() => (init_dist_WGIHRGBZ(), dist_WGIHRGBZ_exports));
           const result = await clackPassword({ message: opts.message, mask });
           return isCancel(result) ? /* @__PURE__ */ Symbol("cancel") : result;
@@ -13420,7 +13440,7 @@ ${ansis_default.cyan(S_BAR_END)}
             dataSource._loadingError = err instanceof SchemaError ? err : new SchemaError(err);
             return;
           }
-          const { ConfigItem: ConfigItem2 } = await Promise.resolve().then(() => (init_config_item_2FQ6I6PO(), config_item_2FQ6I6PO_exports));
+          const { ConfigItem: ConfigItem2 } = await Promise.resolve().then(() => (init_config_item_6LTV4PNH(), config_item_6LTV4PNH_exports));
           for (const [key, entry] of Object.entries(entries)) {
             const existsInSchema = key in graph.configSchema;
             if (!existsInSchema && !createMissing) {
@@ -13477,6 +13497,9 @@ ${ansis_default.cyan(S_BAR_END)}
       {
         name: "icon"
       },
+      {
+        name: "deprecated"
+      },
       // test-only decorators — dropped in release builds
       ...[]
     ];
@@ -14455,6 +14478,18 @@ ${ansis_default.cyan(S_BAR_END)}
         if (explicitIconDec) return explicitIconDec.resolvedValue;
         return this.dataType?.icon;
       }
+      get isDeprecated() {
+        const deprecatedDec = this.getDec("deprecated");
+        if (!deprecatedDec) return false;
+        const val = deprecatedDec.parsedDecorator.simplifiedValue;
+        return val === true || typeof val === "string";
+      }
+      get deprecationMessage() {
+        const deprecatedDec = this.getDec("deprecated");
+        if (!deprecatedDec) return void 0;
+        const val = deprecatedDec.parsedDecorator.simplifiedValue;
+        return typeof val === "string" ? val : void 0;
+      }
       get docsLinks() {
         const links = [];
         if (this.dataType?.docsEntries) {
@@ -15031,7 +15066,9 @@ ${ansis_default.cyan(S_BAR_END)}
           isRequiredDynamic,
           isSensitive,
           icon,
-          docsLinks
+          docsLinks,
+          isDeprecated: this.isDeprecated,
+          deprecationMessage: this.deprecationMessage
         };
       }
     };
@@ -15412,8 +15449,8 @@ function patchGlobalServerResponse(opts) {
 }
 __name(patchGlobalServerResponse, "patchGlobalServerResponse");
 
-// ../../varlock/dist/chunk-FTVXXJMG.js
-init_chunk_U7RQPX5K();
+// ../../varlock/dist/chunk-CDLU5P62.js
+init_chunk_XWYFSG46();
 init_chunk_6PEHRAEP();
 var import_semver2 = __toESM(require_semver2(), 1);
 var MIN_BUN_VERSION = "1.3.3";
@@ -15564,8 +15601,8 @@ function gracefulExit(signal) {
 }
 __name(gracefulExit, "gracefulExit");
 
-// ../../varlock/dist/chunk-GBCB7Y3B.js
-init_chunk_U7RQPX5K();
+// ../../varlock/dist/chunk-QP7TS4SU.js
+init_chunk_XWYFSG46();
 init_chunk_2PFIYNFA();
 init_chunk_6PEHRAEP();
 async function loadEnvGraph(opts) {
@@ -15583,7 +15620,7 @@ async function loadEnvGraph(opts) {
   } else if (rawPaths?.length === 1) {
     const entryFilePath = rawPaths[0];
     const resolvedPath = path3__namespace.default.resolve(entryFilePath);
-    const isDirectory = entryFilePath.endsWith("/") || entryFilePath.endsWith(path3__namespace.default.sep) || fs32__namespace.default.existsSync(resolvedPath) && fs32__namespace.default.statSync(resolvedPath).isDirectory();
+    const isDirectory = entryFilePath.endsWith("/") || entryFilePath.endsWith(path3__namespace.default.sep) || fs5__namespace.default.existsSync(resolvedPath) && fs5__namespace.default.statSync(resolvedPath).isDirectory();
     if (isDirectory) {
       graph.basePath = resolvedPath;
       if (opts?.afterInit) await opts.afterInit(graph);
@@ -15668,9 +15705,10 @@ function getItemSummary(item) {
   const isRequired = item.isRequired;
   summary.push(joinAndCompact([
     icon,
-    ansis_default[VALIDATION_STATE_COLORS[item.validationState]](item.key) + (isRequired ? ansis_default.magenta("*") : ""),
+    ansis_default[VALIDATION_STATE_COLORS[item.validationState]](item.isDeprecated ? ansis_default.strikethrough(item.key) : item.key) + (isRequired ? ansis_default.magenta("*") : ""),
     // ansis.gray(`[type = ${item.type.typeLabel}]`),
-    isSensitive && ` \u{1F510}${ansis_default.gray.italic("sensitive")}`
+    isSensitive && ` \u{1F510}${ansis_default.gray.italic("sensitive")}`,
+    item.isDeprecated && ` \u{1F635}${ansis_default.yellow.dim.italic("deprecated")}`
     // item.useAt ? ansis.gray.italic(`(${item.useAt?.join(', ')})`) : undefined,
   ]));
   let valAsStr = formattedValue(item.resolvedValue, false);
@@ -15721,8 +15759,8 @@ var CliExitError = class extends Error {
   }
 };
 
-// ../../varlock/dist/chunk-UKFHSMKY.js
-init_chunk_U7RQPX5K();
+// ../../varlock/dist/chunk-7GFD2ATN.js
+init_chunk_XWYFSG46();
 init_chunk_2PFIYNFA();
 init_chunk_6PEHRAEP();
 function showErrorLocationDetails(err) {
@@ -15851,25 +15889,9 @@ function checkForConfigErrors(envGraph, opts) {
 }
 __name(checkForConfigErrors, "checkForConfigErrors");
 
-// ../../varlock/dist/chunk-6DXWXIQV.js
-init_chunk_7WB7HK5Z();
+// ../../varlock/dist/chunk-GURKQO4J.js
+init_chunk_O3WTD6L4();
 init_chunk_6PEHRAEP();
-var _isWSL;
-function isWSL() {
-  if (_isWSL !== void 0) return _isWSL;
-  if (process.env.WSL_DISTRO_NAME) {
-    _isWSL = true;
-    return true;
-  }
-  try {
-    const version = fs32__namespace.default.readFileSync("/proc/version", "utf-8");
-    _isWSL = /microsoft|wsl/i.test(version);
-  } catch {
-    _isWSL = false;
-  }
-  return _isWSL;
-}
-__name(isWSL, "isWSL");
 var __dirname$1 = path3__namespace.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('next-env-compat.js', document.baseURI).href))));
 function debug3(msg) {
   if (process.env.VARLOCK_DEBUG) {
@@ -15884,9 +15906,9 @@ function resolvePackageRoot() {
   let dir = __dirname$1;
   for (let i = 0; i < 10; i++) {
     const pkgJsonPath = path3__namespace.default.join(dir, "package.json");
-    if (fs32__namespace.default.existsSync(pkgJsonPath)) {
+    if (fs5__namespace.default.existsSync(pkgJsonPath)) {
       try {
-        const pkgJson = JSON.parse(fs32__namespace.default.readFileSync(pkgJsonPath, "utf-8"));
+        const pkgJson = JSON.parse(fs5__namespace.default.readFileSync(pkgJsonPath, "utf-8"));
         if (pkgJson.name === "varlock") return dir;
       } catch {
       }
@@ -15912,15 +15934,15 @@ function getNativeBinSubdir() {
 __name(getNativeBinSubdir, "getNativeBinSubdir");
 function resolveMacOSBinary(dir) {
   const appBundlePath = path3__namespace.default.join(dir, MACOS_APP_BUNDLE, "Contents", "MacOS", BINARY_NAME);
-  if (fs32__namespace.default.existsSync(appBundlePath)) return appBundlePath;
+  if (fs5__namespace.default.existsSync(appBundlePath)) return appBundlePath;
   const barePath = path3__namespace.default.join(dir, BINARY_NAME);
-  if (fs32__namespace.default.existsSync(barePath)) return barePath;
+  if (fs5__namespace.default.existsSync(barePath)) return barePath;
   return void 0;
 }
 __name(resolveMacOSBinary, "resolveMacOSBinary");
 function resolveStandardBinary(dir) {
   const binaryPath = path3__namespace.default.join(dir, getPlatformBinaryName());
-  if (fs32__namespace.default.existsSync(binaryPath)) return binaryPath;
+  if (fs5__namespace.default.existsSync(binaryPath)) return binaryPath;
   return void 0;
 }
 __name(resolveStandardBinary, "resolveStandardBinary");
@@ -15930,7 +15952,7 @@ function resolveBinaryFromDir(dir) {
 }
 __name(resolveBinaryFromDir, "resolveBinaryFromDir");
 function resolveSeaSibling() {
-  const execDir = path3__namespace.default.dirname(fs32__namespace.default.realpathSync(process.execPath));
+  const execDir = path3__namespace.default.dirname(fs5__namespace.default.realpathSync(process.execPath));
   const sibling = resolveBinaryFromDir(execDir);
   if (sibling) return sibling;
   const libexecDir = path3__namespace.default.join(execDir, "..", "libexec");
@@ -15940,9 +15962,9 @@ __name(resolveSeaSibling, "resolveSeaSibling");
 function resolveNpmBundled() {
   const packageRoot = resolvePackageRoot();
   const nativeBinsDir = path3__namespace.default.join(packageRoot, "native-bins", getNativeBinSubdir());
-  if (fs32__namespace.default.existsSync(nativeBinsDir)) return resolveBinaryFromDir(nativeBinsDir);
+  if (fs5__namespace.default.existsSync(nativeBinsDir)) return resolveBinaryFromDir(nativeBinsDir);
   const adjacentNativeBinsDir = path3__namespace.default.join(path3__namespace.default.dirname(packageRoot), "native-bins", getNativeBinSubdir());
-  if (fs32__namespace.default.existsSync(adjacentNativeBinsDir)) return resolveBinaryFromDir(adjacentNativeBinsDir);
+  if (fs5__namespace.default.existsSync(adjacentNativeBinsDir)) return resolveBinaryFromDir(adjacentNativeBinsDir);
   return void 0;
 }
 __name(resolveNpmBundled, "resolveNpmBundled");
@@ -15954,20 +15976,20 @@ function resolveDevFallback() {
     dir = parent;
     if (process.platform === "darwin") {
       const swiftBuild = path3__namespace.default.join(dir, "packages", "encryption-binary-swift", "swift", ".build", "release", "VarlockEnclave");
-      if (fs32__namespace.default.existsSync(swiftBuild)) return swiftBuild;
+      if (fs5__namespace.default.existsSync(swiftBuild)) return swiftBuild;
     }
     const rustBuild = path3__namespace.default.join(dir, "packages", "encryption-binary-rust", "target", "release", getPlatformBinaryName());
-    if (fs32__namespace.default.existsSync(rustBuild)) return rustBuild;
+    if (fs5__namespace.default.existsSync(rustBuild)) return rustBuild;
   }
   return void 0;
 }
 __name(resolveDevFallback, "resolveDevFallback");
 function ensureExecutable(binaryPath) {
   try {
-    fs32__namespace.default.accessSync(binaryPath, fs32__namespace.default.constants.X_OK);
+    fs5__namespace.default.accessSync(binaryPath, fs5__namespace.default.constants.X_OK);
   } catch {
     if (process.platform !== "win32") {
-      fs32__namespace.default.chmodSync(binaryPath, 493);
+      fs5__namespace.default.chmodSync(binaryPath, 493);
     }
   }
   return binaryPath;
@@ -16008,6 +16030,10 @@ function resolveNativeBinary() {
   return void 0;
 }
 __name(resolveNativeBinary, "resolveNativeBinary");
+var SEND_TIMEOUT_MS = 3e4;
+var BIOMETRIC_TIMEOUT_MS = 9e4;
+var INTERACTIVE_TIMEOUT_MS = 5 * 6e4;
+var KILL_GRACE_MS = 2e3;
 function debug22(msg) {
   if (process.env.VARLOCK_DEBUG) {
     process.stderr.write(`[varlock:daemon-client] ${msg}
@@ -16015,6 +16041,40 @@ function debug22(msg) {
   }
 }
 __name(debug22, "debug");
+function killDaemonProcess(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return true;
+  }
+  const start = Date.now();
+  while (Date.now() - start < KILL_GRACE_MS) {
+    try {
+      process.kill(pid, 0);
+    } catch {
+      return true;
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+  }
+  debug22(`daemon pid ${pid} didn't respond to SIGTERM, sending SIGKILL`);
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    return true;
+  }
+  const killStart = Date.now();
+  while (Date.now() - killStart < 500) {
+    try {
+      process.kill(pid, 0);
+    } catch {
+      return true;
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+  }
+  debug22(`daemon pid ${pid} is unkillable (likely in uninterruptible kernel wait) \u2014 proceeding anyway`);
+  return false;
+}
+__name(killDaemonProcess, "killDaemonProcess");
 function getSocketDir() {
   return path3__namespace.default.join(getUserVarlockDir(), "local-encrypt");
 }
@@ -16026,6 +16086,10 @@ function getSocketPath() {
   return path3__namespace.default.join(getSocketDir(), "daemon.sock");
 }
 __name(getSocketPath, "getSocketPath");
+function getLockPath() {
+  return `${getSocketPath()}.lock`;
+}
+__name(getLockPath, "getLockPath");
 function getPidPath() {
   return path3__namespace.default.join(getSocketDir(), "daemon.pid");
 }
@@ -16034,12 +16098,29 @@ function getDaemonInfoPath() {
   return path3__namespace.default.join(getSocketDir(), "daemon.info");
 }
 __name(getDaemonInfoPath, "getDaemonInfoPath");
+function getDaemonStateFiles() {
+  const files = [getPidPath(), getDaemonInfoPath()];
+  if (process.platform !== "win32") {
+    files.push(getSocketPath(), getLockPath());
+  }
+  return files;
+}
+__name(getDaemonStateFiles, "getDaemonStateFiles");
+function cleanupDaemonFiles() {
+  for (const file of getDaemonStateFiles()) {
+    try {
+      fs5__namespace.default.unlinkSync(file);
+    } catch {
+    }
+  }
+}
+__name(cleanupDaemonFiles, "cleanupDaemonFiles");
 function checkDaemonBinaryStale() {
   const infoPath = getDaemonInfoPath();
   const pidPath = getPidPath();
   let info;
   try {
-    info = JSON.parse(fs32__namespace.default.readFileSync(infoPath, "utf-8"));
+    info = JSON.parse(fs5__namespace.default.readFileSync(infoPath, "utf-8"));
   } catch {
   }
   const currentBinaryPath = resolveNativeBinary();
@@ -16049,7 +16130,7 @@ function checkDaemonBinaryStale() {
       debug22(`daemon binary path changed: ${info.binaryPath} \u2192 ${currentBinaryPath}`);
     } else {
       try {
-        const stat = fs32__namespace.default.statSync(currentBinaryPath);
+        const stat = fs5__namespace.default.statSync(currentBinaryPath);
         if (stat.mtimeMs === info.binaryMtimeMs) {
           debug22("daemon binary is current \u2014 no restart needed");
           return void 0;
@@ -16063,18 +16144,20 @@ function checkDaemonBinaryStale() {
     debug22("no daemon.info file \u2014 treating running daemon as stale");
   }
   try {
-    const pid = parseInt(fs32__namespace.default.readFileSync(pidPath, "utf-8").trim(), 10);
+    const pid = parseInt(fs5__namespace.default.readFileSync(pidPath, "utf-8").trim(), 10);
     process.kill(pid, 0);
     return pid;
   } catch {
+    debug22("stale PID file points to dead process \u2014 cleaning up");
+    cleanupDaemonFiles();
     return void 0;
   }
 }
 __name(checkDaemonBinaryStale, "checkDaemonBinaryStale");
 function writeDaemonInfo(binaryPath) {
   try {
-    const stat = fs32__namespace.default.statSync(binaryPath);
-    fs32__namespace.default.writeFileSync(getDaemonInfoPath(), JSON.stringify({
+    const stat = fs5__namespace.default.statSync(binaryPath);
+    fs5__namespace.default.writeFileSync(getDaemonInfoPath(), JSON.stringify({
       binaryPath,
       binaryMtimeMs: stat.mtimeMs
     }));
@@ -16122,22 +16205,8 @@ var DaemonClient = class {
     const stalePid = this.spawnedInThisProcess ? void 0 : checkDaemonBinaryStale();
     if (stalePid) {
       debug22(`killing stale daemon (pid ${stalePid}) \u2014 binary has been updated`);
-      try {
-        process.kill(stalePid, "SIGTERM");
-      } catch {
-      }
-      for (const file of [getPidPath(), getDaemonInfoPath()]) {
-        try {
-          fs32__namespace.default.unlinkSync(file);
-        } catch {
-        }
-      }
-      if (process.platform !== "win32") {
-        try {
-          fs32__namespace.default.unlinkSync(socketPath);
-        } catch {
-        }
-      }
+      killDaemonProcess(stalePid);
+      cleanupDaemonFiles();
     } else {
       try {
         await this.connectToSocket(socketPath);
@@ -16147,7 +16216,8 @@ var DaemonClient = class {
     }
     try {
       await this.spawnDaemon();
-    } catch {
+    } catch (err) {
+      debug22(`spawnDaemon failed: ${err instanceof Error ? err.message : err}`);
       await new Promise((r) => {
         setTimeout(r, 1e3);
       });
@@ -16155,76 +16225,88 @@ var DaemonClient = class {
     await this.connectToSocket(socketPath);
   }
   async decrypt(ciphertext, keyId = "varlock-default") {
-    await this.ensureConnected();
-    const result = await this.sendMessage({
-      action: "decrypt",
-      payload: { ciphertext, keyId }
+    return this.withRetry(async () => {
+      await this.ensureConnected();
+      const result = await this.sendMessage({
+        action: "decrypt",
+        payload: { ciphertext, keyId }
+      }, BIOMETRIC_TIMEOUT_MS);
+      if (typeof result === "string") return result;
+      if (result && typeof result === "object" && "error" in result) {
+        throw new Error(String(result.error));
+      }
+      return String(result);
     });
-    if (typeof result === "string") return result;
-    if (result && typeof result === "object" && "error" in result) {
-      throw new Error(String(result.error));
-    }
-    return String(result);
   }
   async promptSecret(opts) {
-    await this.ensureConnected();
-    try {
-      const result = await this.sendMessage({
-        action: "prompt-secret",
-        payload: {
-          itemKey: opts?.itemKey,
-          message: opts?.message,
-          keyId: opts?.keyId
+    return this.withRetry(async () => {
+      await this.ensureConnected();
+      try {
+        const result = await this.sendMessage({
+          action: "prompt-secret",
+          payload: {
+            itemKey: opts?.itemKey,
+            message: opts?.message,
+            keyId: opts?.keyId
+          }
+        }, INTERACTIVE_TIMEOUT_MS);
+        if (result && typeof result === "object" && "ciphertext" in result) {
+          return result.ciphertext;
         }
-      });
-      if (result && typeof result === "object" && "ciphertext" in result) {
-        return result.ciphertext;
+        return void 0;
+      } catch (err) {
+        if (err instanceof Error && err.message === "cancelled") return void 0;
+        throw err;
       }
-      return void 0;
-    } catch (err) {
-      if (err instanceof Error && err.message === "cancelled") return void 0;
-      throw err;
-    }
+    });
   }
   async invalidateSession() {
-    await this.ensureConnected();
-    await this.sendMessage({ action: "invalidate-session" });
+    return this.withRetry(async () => {
+      await this.ensureConnected();
+      await this.sendMessage({ action: "invalidate-session" });
+    });
   }
   async keychainGet(opts) {
-    await this.ensureConnected();
-    const result = await this.sendMessage({
-      action: "keychain-get",
-      payload: opts
+    return this.withRetry(async () => {
+      await this.ensureConnected();
+      const result = await this.sendMessage({
+        action: "keychain-get",
+        payload: opts
+      }, BIOMETRIC_TIMEOUT_MS);
+      if (typeof result === "string") return result;
+      if (result && typeof result === "object" && "error" in result) {
+        throw new Error(String(result.error));
+      }
+      return String(result);
     });
-    if (typeof result === "string") return result;
-    if (result && typeof result === "object" && "error" in result) {
-      throw new Error(String(result.error));
-    }
-    return String(result);
   }
   async keychainSearch(opts) {
-    await this.ensureConnected();
-    const result = await this.sendMessage({
-      action: "keychain-search",
-      payload: opts ?? {}
+    return this.withRetry(async () => {
+      await this.ensureConnected();
+      const result = await this.sendMessage({
+        action: "keychain-search",
+        payload: opts ?? {}
+      });
+      return result ?? [];
     });
-    return result ?? [];
   }
   async keychainPick(opts) {
-    await this.ensureConnected();
-    try {
-      const result = await this.sendMessage({
-        action: "keychain-pick",
-        payload: { itemKey: opts?.itemKey }
-      });
-      if (result && typeof result === "object" && "service" in result) {
-        return result;
+    return this.withRetry(async () => {
+      await this.ensureConnected();
+      try {
+        const result = await this.sendMessage({
+          action: "keychain-pick",
+          payload: { itemKey: opts?.itemKey }
+        }, INTERACTIVE_TIMEOUT_MS);
+        if (result && typeof result === "object" && "service" in result) {
+          return result;
+        }
+        return void 0;
+      } catch (err) {
+        if (err instanceof Error && err.message === "cancelled") return void 0;
+        throw err;
       }
-      return void 0;
-    } catch (err) {
-      if (err instanceof Error && err.message === "cancelled") return void 0;
-      throw err;
-    }
+    });
   }
   cleanup() {
     for (const { reject } of this.messageQueue.values()) {
@@ -16237,6 +16319,37 @@ var DaemonClient = class {
     this.buffer = Buffer.alloc(0);
   }
   // -- Private --
+  /**
+   * Run an async operation, and on recoverable failure (timeout, connection
+   * closed) clean up, reconnect to the daemon, and retry once.
+   */
+  async withRetry(fn) {
+    try {
+      return await fn();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "";
+      const recoverable = msg.includes("timed out") || msg.includes("connection closed") || msg.includes("Not connected");
+      if (!recoverable) throw err;
+      debug22(`recoverable error, reconnecting: ${msg}`);
+      this.forceCleanup();
+      await this.ensureConnected();
+      return await fn();
+    }
+  }
+  /**
+   * Aggressive cleanup: kill the daemon process if we know its PID,
+   * then reset client state so the next ensureConnected spawns fresh.
+   */
+  forceCleanup() {
+    this.cleanup();
+    this.spawnedInThisProcess = false;
+    try {
+      const pid = parseInt(fs5__namespace.default.readFileSync(getPidPath(), "utf-8").trim(), 10);
+      killDaemonProcess(pid);
+    } catch {
+    }
+    cleanupDaemonFiles();
+  }
   connectToSocket(socketPath) {
     return new Promise((resolve2, reject) => {
       const socket = new net__default.default.Socket();
@@ -16262,6 +16375,11 @@ var DaemonClient = class {
       socket.on("close", () => {
         this.isConnected = false;
         this.socket = null;
+        for (const { reject: rej } of this.messageQueue.values()) {
+          rej(new Error("Daemon connection closed"));
+        }
+        this.messageQueue.clear();
+        this.buffer = Buffer.alloc(0);
       });
       socket.connect(socketPath);
     });
@@ -16288,7 +16406,7 @@ var DaemonClient = class {
       }
     }
   }
-  sendMessage(message) {
+  sendMessage(message, timeoutMs = SEND_TIMEOUT_MS) {
     return new Promise((resolve2, reject) => {
       if (!this.isConnected || !this.socket) {
         reject(new Error("Not connected to daemon"));
@@ -16300,7 +16418,20 @@ var DaemonClient = class {
       const messageBytes = Buffer.from(jsonData, "utf-8");
       const lengthBuf = Buffer.alloc(4);
       lengthBuf.writeUInt32LE(messageBytes.length, 0);
-      this.messageQueue.set(messageId, { resolve: resolve2, reject });
+      const timeout = setTimeout(() => {
+        this.messageQueue.delete(messageId);
+        reject(new Error(`Daemon message timed out after ${timeoutMs}ms (action: ${message.action})`));
+      }, timeoutMs);
+      this.messageQueue.set(messageId, {
+        resolve: /* @__PURE__ */ __name((value) => {
+          clearTimeout(timeout);
+          resolve2(value);
+        }, "resolve"),
+        reject: /* @__PURE__ */ __name((err) => {
+          clearTimeout(timeout);
+          reject(err);
+        }, "reject")
+      });
       this.socket.write(Buffer.concat([lengthBuf, messageBytes]));
     });
   }
@@ -16313,35 +16444,26 @@ var DaemonClient = class {
     const pidPath = getPidPath();
     const isWindows2 = process.platform === "win32";
     if (!isWindows2) {
-      fs32__namespace.default.mkdirSync(path3__namespace.default.dirname(socketPath), { recursive: true });
+      fs5__namespace.default.mkdirSync(path3__namespace.default.dirname(socketPath), { recursive: true });
     }
-    fs32__namespace.default.mkdirSync(path3__namespace.default.dirname(pidPath), { recursive: true });
-    if (fs32__namespace.default.existsSync(pidPath)) {
+    fs5__namespace.default.mkdirSync(path3__namespace.default.dirname(pidPath), { recursive: true });
+    if (fs5__namespace.default.existsSync(pidPath)) {
       try {
-        const pid = parseInt(fs32__namespace.default.readFileSync(pidPath, "utf-8").trim(), 10);
+        const pid = parseInt(fs5__namespace.default.readFileSync(pidPath, "utf-8").trim(), 10);
         process.kill(pid, 0);
-        await new Promise((r) => {
-          setTimeout(r, 500);
-        });
-        return;
+        try {
+          await this.connectToSocket(socketPath);
+          return;
+        } catch {
+          debug22(`daemon pid ${pid} alive but socket unresponsive \u2014 killing`);
+          killDaemonProcess(pid);
+        }
       } catch {
       }
     }
-    if (!isWindows2) {
-      for (const file of [socketPath, pidPath, getDaemonInfoPath()]) {
-        if (fs32__namespace.default.existsSync(file)) {
-          fs32__namespace.default.unlinkSync(file);
-        }
-      }
-      if (fs32__namespace.default.existsSync(socketPath)) {
-        throw new Error(`Failed to clean up stale socket file: ${socketPath}`);
-      }
-    } else {
-      for (const file of [pidPath, getDaemonInfoPath()]) {
-        if (fs32__namespace.default.existsSync(file)) {
-          fs32__namespace.default.unlinkSync(file);
-        }
-      }
+    cleanupDaemonFiles();
+    if (!isWindows2 && fs5__namespace.default.existsSync(socketPath)) {
+      throw new Error(`Failed to clean up stale socket file: ${socketPath}`);
     }
     return new Promise((resolve2, reject) => {
       const child = child_process.spawn(binaryPath, [
@@ -16551,7 +16673,7 @@ function getKeyFilePath(keyId) {
 }
 __name(getKeyFilePath, "getKeyFilePath");
 function keyExists(keyId = DEFAULT_KEY_ID) {
-  return fs32__namespace.default.existsSync(getKeyFilePath(keyId));
+  return fs5__namespace.default.existsSync(getKeyFilePath(keyId));
 }
 __name(keyExists, "keyExists");
 async function generateKey(keyId = DEFAULT_KEY_ID) {
@@ -16563,18 +16685,18 @@ async function generateKey(keyId = DEFAULT_KEY_ID) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   const keyStorePath = getKeyStorePath();
-  fs32__namespace.default.mkdirSync(keyStorePath, { recursive: true });
+  fs5__namespace.default.mkdirSync(keyStorePath, { recursive: true });
   const filePath = getKeyFilePath(keyId);
-  fs32__namespace.default.writeFileSync(filePath, JSON.stringify(stored, null, 2), { mode: 384 });
+  fs5__namespace.default.writeFileSync(filePath, JSON.stringify(stored, null, 2), { mode: 384 });
   return { keyId, publicKey: keyPair.publicKey };
 }
 __name(generateKey, "generateKey");
 function loadKeyPair(keyId) {
   const filePath = getKeyFilePath(keyId);
-  if (!fs32__namespace.default.existsSync(filePath)) {
+  if (!fs5__namespace.default.existsSync(filePath)) {
     throw new Error(`Key not found: ${keyId}`);
   }
-  const data = fs32__namespace.default.readFileSync(filePath, "utf-8");
+  const data = fs5__namespace.default.readFileSync(filePath, "utf-8");
   const parsed = JSON.parse(data);
   const privateKey = parsed.privateKey ?? (parsed.protection === "none" ? parsed.protectedPrivateKey : void 0) ?? parsed.protectedPrivateKey;
   if (!parsed.publicKey || !privateKey) {
@@ -16612,21 +16734,49 @@ function debug32(msg) {
   }
 }
 __name(debug32, "debug");
-var _cachedTtyId;
-function getSelfTtyId() {
-  if (_cachedTtyId) return _cachedTtyId;
+var _cachedSessionId;
+function getSelfSessionId() {
+  if (_cachedSessionId) return _cachedSessionId;
   try {
-    const ttyPath = fs32__namespace.default.readlinkSync("/proc/self/fd/0");
+    const ttyPath = fs5__namespace.default.readlinkSync("/proc/self/fd/0");
     if (ttyPath && ttyPath.startsWith("/dev/")) {
-      _cachedTtyId = ttyPath;
+      _cachedSessionId = ttyPath;
       return ttyPath;
     }
   } catch {
   }
-  _cachedTtyId = `pid:${process.pid}`;
-  return _cachedTtyId;
+  try {
+    const chain = [process.pid];
+    let current = process.pid;
+    for (let i = 0; i < 64; i++) {
+      const stat = fs5__namespace.default.readFileSync(`/proc/${current}/stat`, "utf-8");
+      const fields = stat.split(") ");
+      if (fields.length < 2) break;
+      const ppid = parseInt(fields[1].split(" ")[1], 10);
+      if (!ppid || ppid <= 1) break;
+      chain.push(ppid);
+      current = ppid;
+    }
+    if (chain.length >= 4) {
+      const scopePid = chain[chain.length - 3];
+      let startTime = 0;
+      try {
+        const scopeStat = fs5__namespace.default.readFileSync(`/proc/${scopePid}/stat`, "utf-8");
+        const scopeFields = scopeStat.split(") ");
+        if (scopeFields.length >= 2) {
+          startTime = parseInt(scopeFields[1].split(" ")[19], 10) || 0;
+        }
+      } catch {
+      }
+      _cachedSessionId = `ptree:${scopePid}:${startTime}`;
+      return _cachedSessionId;
+    }
+  } catch {
+  }
+  _cachedSessionId = `pid:${process.pid}`;
+  return _cachedSessionId;
 }
-__name(getSelfTtyId, "getSelfTtyId");
+__name(getSelfSessionId, "getSelfSessionId");
 var _wslDaemonPrestartAttempted = false;
 function toWindowsPathFromWsl(pathInWsl) {
   if (!isWSL()) return void 0;
@@ -16870,7 +17020,7 @@ async function decryptValue2(ciphertext, keyId = DEFAULT_KEY_ID2) {
       }
       const stdinPayload = JSON.stringify({
         data: ciphertext,
-        ttyId: getSelfTtyId()
+        ttyId: getSelfSessionId()
       });
       const runViaDaemon = /* @__PURE__ */ __name((timeout) => child_process.spawnSync(binaryPath, ["decrypt", "--key-id", keyId, "--data-stdin", "--via-daemon"], {
         input: stdinPayload,
@@ -16928,15 +17078,15 @@ async function lockSession() {
 }
 __name(lockSession, "lockSession");
 
-// ../../varlock/dist/chunk-V2MTE4J6.js
-init_chunk_U7RQPX5K();
+// ../../varlock/dist/chunk-E3F6QKDZ.js
+init_chunk_XWYFSG46();
 init_chunk_2PFIYNFA();
 init_chunk_6PEHRAEP();
 function writeBackValue(itemKey, newValueStr, sourceFilePath) {
   if (!sourceFilePath) {
     return { updated: false, reason: "missing-source-file" };
   }
-  const currentContents = fs32__namespace.default.readFileSync(sourceFilePath, "utf-8");
+  const currentContents = fs5__namespace.default.readFileSync(sourceFilePath, "utf-8");
   const file = parseEnvSpecDotEnvFile(currentContents);
   const item = file.configItems.find((i) => i.key === itemKey);
   if (!item) {
@@ -16949,7 +17099,7 @@ function writeBackValue(itemKey, newValueStr, sourceFilePath) {
   }
   item.data.value = dummyItem.value;
   item.value = dummyItem.value;
-  fs32__namespace.default.writeFileSync(sourceFilePath, file.toString());
+  fs5__namespace.default.writeFileSync(sourceFilePath, file.toString());
   return { updated: true };
 }
 __name(writeBackValue, "writeBackValue");
@@ -17269,9 +17419,9 @@ var KeychainResolver = createResolver({
 function readVarlockPackageJsonConfig(opts) {
   const cwd = opts?.cwd ?? process.cwd();
   const pkgPath = path3__namespace.default.join(cwd, "package.json");
-  if (!fs32__namespace.default.existsSync(pkgPath)) return void 0;
+  if (!fs5__namespace.default.existsSync(pkgPath)) return void 0;
   try {
-    const pkg = JSON.parse(fs32__namespace.default.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs5__namespace.default.readFileSync(pkgPath, "utf-8"));
     if (pkg.varlock && typeof pkg.varlock === "object") {
       return pkg.varlock;
     }
@@ -17294,7 +17444,7 @@ function loadFromPaths(rawPaths, config) {
     debug4("using %d paths from %s: %s", resolvedPaths.length, config.source, resolvedPaths.join(", "));
   }
   for (const resolvedPath of resolvedPaths) {
-    if (!fs32__namespace.default.existsSync(resolvedPath)) {
+    if (!fs5__namespace.default.existsSync(resolvedPath)) {
       throw new CliExitError(`${config.errorPrefix}: ${resolvedPath}`, {
         suggestion: config.errorSuggestion
       });
@@ -17342,8 +17492,8 @@ function loadVarlockEnvGraph(opts) {
 __name(loadVarlockEnvGraph, "loadVarlockEnvGraph");
 
 // ../../varlock/dist/index.js
-init_chunk_U7RQPX5K();
-init_chunk_7WB7HK5Z();
+init_chunk_XWYFSG46();
+init_chunk_O3WTD6L4();
 init_chunk_HDKXXS2X();
 init_chunk_2PFIYNFA();
 init_chunk_2PFIYNFA();
@@ -17418,7 +17568,7 @@ init_chunk_6PEHRAEP();
 // ../../varlock/dist/runtime/patch-console.js
 init_chunk_6PEHRAEP();
 
-// ../../varlock/dist/chunk-YHOWSHVH.js
+// ../../varlock/dist/chunk-F5H5MJ6U.js
 init_chunk_6PEHRAEP();
 var platform = os__default.default.platform();
 var isWindows = platform.match(/^win/i);
@@ -17427,10 +17577,10 @@ function findVarlockBin(startDir) {
   let currentDir = startDir;
   while (currentDir) {
     const possibleBinPath = path3__namespace.default.join(currentDir, "node_modules", ".bin");
-    if (fs32__namespace.default.existsSync(possibleBinPath)) {
+    if (fs5__namespace.default.existsSync(possibleBinPath)) {
       for (const binName of binNames) {
         const possibleVarlockPath = path3__namespace.default.join(possibleBinPath, binName);
-        if (fs32__namespace.default.existsSync(possibleVarlockPath)) {
+        if (fs5__namespace.default.existsSync(possibleVarlockPath)) {
           return possibleVarlockPath;
         }
       }
@@ -17442,6 +17592,20 @@ function findVarlockBin(startDir) {
   return null;
 }
 __name(findVarlockBin, "findVarlockBin");
+var VarlockExecError = class extends Error {
+  constructor(message, stdout2, stderr, exitCode) {
+    super(message);
+    this.stdout = stdout2;
+    this.stderr = stderr;
+    this.exitCode = exitCode;
+  }
+  stdout;
+  stderr;
+  exitCode;
+  static {
+    __name(this, "VarlockExecError");
+  }
+};
 function execSyncVarlock(command, opts) {
   try {
     try {
@@ -17450,7 +17614,7 @@ function execSyncVarlock(command, opts) {
         ...opts?.cwd && { cwd: opts.cwd },
         stdio: "pipe"
       });
-      return result.toString();
+      return opts?.fullResult ? { stdout: result.toString(), stderr: "" } : result.toString();
     } catch (err) {
       if (!isWindows && err.status !== 127 && err.code !== "ENOENT") throw err;
     }
@@ -17469,11 +17633,24 @@ function execSyncVarlock(command, opts) {
           stdio: "pipe",
           ...needsShell && { shell: true }
         });
-        return result.toString();
+        return opts?.fullResult ? { stdout: result.toString(), stderr: "" } : result.toString();
       }
     }
     throw new Error("Unable to find varlock executable");
   } catch (err) {
+    if (opts?.fullResult) {
+      if (err instanceof VarlockExecError) throw err;
+      const errAny2 = err;
+      if (errAny2.status != null) {
+        throw new VarlockExecError(
+          `varlock ${command} failed (exit code ${errAny2.status})`,
+          errAny2.stdout?.toString() ?? "",
+          errAny2.stderr?.toString() ?? "",
+          errAny2.status ?? 1
+        );
+      }
+      throw err;
+    }
     const errAny = err;
     if (opts?.showLogsOnError) {
       if (errAny.stdout) console.log(errAny.stdout.toString());
@@ -17543,7 +17720,7 @@ function enableExtraFileWatchers(sources, basePath) {
   let triggerFilePath = null;
   for (const envFileName of NEXT_WATCHED_ENV_FILES) {
     const filePath = path3__namespace.join(rootDir, envFileName);
-    if (fs32__namespace.existsSync(filePath)) {
+    if (fs5__namespace.existsSync(filePath)) {
       triggerFilePath = filePath;
       break;
     }
@@ -17553,7 +17730,7 @@ function enableExtraFileWatchers(sources, basePath) {
   function triggerNextReload(changedPath) {
     debug5("extra file changed, triggering reload:", changedPath);
     if (mustDestroyTriggerFile) {
-      fs32__namespace.writeFileSync(triggerFilePath, [
+      fs5__namespace.writeFileSync(triggerFilePath, [
         "# This file was created by @varlock/nextjs-integration",
         "# It is used to trigger Next.js to reload when non-standard .env files change",
         "# You can safely ignore and delete it",
@@ -17562,19 +17739,19 @@ function enableExtraFileWatchers(sources, basePath) {
       ].join("\n"), "utf-8");
       setTimeout(() => {
         try {
-          fs32__namespace.unlinkSync(triggerFilePath);
+          fs5__namespace.unlinkSync(triggerFilePath);
         } catch {
         }
       }, 1e3);
     } else {
-      const currentContents = fs32__namespace.readFileSync(triggerFilePath, "utf-8");
-      fs32__namespace.writeFileSync(triggerFilePath, currentContents, "utf-8");
+      const currentContents = fs5__namespace.readFileSync(triggerFilePath, "utf-8");
+      fs5__namespace.writeFileSync(triggerFilePath, currentContents, "utf-8");
     }
   }
   debug5("setting up extra file watchers for:", extraFilePaths);
   for (const filePath of extraFilePaths) {
     watchedExtraFiles.add(filePath);
-    fs32__namespace.watchFile(filePath, { interval: 500 }, () => {
+    fs5__namespace.watchFile(filePath, { interval: 500 }, () => {
       triggerNextReload(filePath);
     });
   }
@@ -17644,17 +17821,14 @@ function loadEnvConfig(dir, dev, _log = console, forceReload = false, _onReload)
   try {
     const cleanEnv = { ...exports.initialEnv };
     delete cleanEnv.DEBUG_VARLOCK;
-    const varlockLoadedEnvStr = execSyncVarlock(`load --format json-full --env ${envFromNextCommand}`, {
-      // We handle all error display and exit logic ourselves in the catch block
-      // so we can silently defer on serverless platforms where the binary is missing.
-      showLogsOnError: false,
-      exitOnError: false,
+    const { stdout: stdout2 } = execSyncVarlock(`load --format json-full --env ${envFromNextCommand}`, {
+      fullResult: true,
       env: cleanEnv
     });
     if (loadCount >= 2) {
       console.log("\u2705 env reloaded and validated");
     }
-    varlockLoadedEnv = JSON.parse(varlockLoadedEnvStr);
+    varlockLoadedEnv = JSON.parse(stdout2);
   } catch (err) {
     if (err.message.includes("Unable to find varlock executable")) {
       if (!dev) {
@@ -17670,12 +17844,12 @@ function loadEnvConfig(dir, dev, _log = console, forceReload = false, _onReload)
       ].join("\n"));
       process.exit(1);
     }
-    const errAny = err;
-    if (errAny.stdout) console.log(errAny.stdout.toString());
-    if (errAny.stderr) console.error(errAny.stderr.toString());
-    console.error("[varlock] \u26A0\uFE0F failed to load env \u2014 see error above");
+    if (err instanceof VarlockExecError) {
+      if (err.stderr) process.stderr.write(err.stderr);
+      console.error("[varlock] \u26A0\uFE0F failed to load env \u2014 see error above");
+    }
     if (!dev) {
-      process.exit(err.status ?? 1);
+      process.exit(err.exitCode ?? 1);
     }
     process.env.__VARLOCK_ENV = JSON.stringify({
       sources: [],