@swmansion/argent 0.29.1-next.9 → 0.30.0

package/dist/client.js

@@ -35,322 +35,395 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../node_modules/dotenv/lib/main.js
-var require_main = __commonJS({
-  "../../node_modules/dotenv/lib/main.js"(exports, module) {
-    var fs7 = __require("fs");
-    var path13 = __require("path");
-    var os2 = __require("os");
-    var crypto2 = __require("crypto");
-    var TIPS = [
-      "\u25C8 encrypted .env [www.dotenvx.com]",
-      "\u25C8 secrets for agents [www.dotenvx.com]",
-      "\u2301 auth for agents [www.vestauth.com]",
-      "\u2318 custom filepath { path: '/custom/path/.env' }",
-      "\u2318 enable debugging { debug: true }",
-      "\u2318 override existing { override: true }",
-      "\u2318 suppress logs { quiet: true }",
-      "\u2318 multiple files { path: ['.env.local', '.env'] }"
-    ];
-    function _getRandomTip() {
-      return TIPS[Math.floor(Math.random() * TIPS.length)];
-    }
-    function parseBoolean(value) {
-      if (typeof value === "string") {
-        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
-      }
-      return Boolean(value);
-    }
-    function supportsAnsi() {
-      return process.stdout.isTTY;
-    }
-    function dim(text) {
-      return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
-    }
-    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
-    function parse(src) {
-      const obj = {};
-      let lines = src.toString();
-      lines = lines.replace(/\r\n?/mg, "\n");
-      let match;
-      while ((match = LINE.exec(lines)) != null) {
-        const key = match[1];
-        let value = match[2] || "";
-        value = value.trim();
-        const maybeQuote = value[0];
-        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
-        if (maybeQuote === '"') {
-          value = value.replace(/\\n/g, "\n");
-          value = value.replace(/\\r/g, "\r");
-        }
-        obj[key] = value;
-      }
-      return obj;
-    }
-    function _parseVault(options) {
-      options = options || {};
-      const vaultPath = _vaultPath(options);
-      options.path = vaultPath;
-      const result = DotenvModule.configDotenv(options);
-      if (!result.parsed) {
-        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
-        err.code = "MISSING_DATA";
-        throw err;
-      }
-      const keys = _dotenvKey(options).split(",");
-      const length = keys.length;
-      let decrypted;
-      for (let i = 0; i < length; i++) {
-        try {
-          const key = keys[i].trim();
-          const attrs = _instructions(result, key);
-          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
-          break;
-        } catch (error) {
-          if (i + 1 >= length) {
-            throw error;
-          }
+// ../../node_modules/dotenv/dist/index.cjs
+var require_dist = __commonJS({
+  "../../node_modules/dotenv/dist/index.cjs"(exports, module) {
+    var j = (e, n) => () => {
+      try {
+        return n || e((n = { exports: {} }).exports, n), n.exports;
+      } catch (t) {
+        throw n = 0, t;
+      }
+    };
+    var k = j((xe, U) => {
+      function G(e) {
+        return typeof e == "string" ? !["false", "0", "no", "off", ""].includes(e.toLowerCase()) : !!e;
+      }
+      function Y(e = process.env) {
+        let n = {};
+        for (let t of ["ENCODING", "PATH", "QUIET", "DEBUG", "OVERRIDE", "FAST"]) {
+          let o = e[`DOTENV_${t}`] != null ? e[`DOTENV_${t}`] : e[`DOTENV_CONFIG_${t}`];
+          o != null && (n[t.toLowerCase()] = t === "ENCODING" || t === "PATH" ? o : G(o));
         }
+        return n;
       }
-      return DotenvModule.parse(decrypted);
-    }
-    function _warn(message) {
-      console.error(`\u26A0 ${message}`);
-    }
-    function _debug(message) {
-      console.log(`\u2506 ${message}`);
-    }
-    function _log(message) {
-      console.log(`\u25C7 ${message}`);
-    }
-    function _dotenvKey(options) {
-      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
-        return options.DOTENV_KEY;
+      U.exports = { parseBoolean: G, optionsFromEnv: Y };
+    });
+    var N = j((ye, x) => {
+      var z = __require("fs"), I = __require("path"), Z = __require("os"), { URL: ee, fileURLToPath: te } = __require("url"), { parseBoolean: $, optionsFromEnv: B } = k(), re = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg, b = new Uint8Array(256);
+      for (let e = 48; e <= 57; e++) b[e] = 1;
+      for (let e = 65; e <= 90; e++) b[e] = 1;
+      for (let e = 97; e <= 122; e++) b[e] = 1;
+      b[45] = 1;
+      b[46] = 1;
+      b[95] = 1;
+      function ne(e) {
+        let n = {}, t = e.toString();
+        t = t.replace(/\r\n?/mg, `
+`);
+        let o;
+        for (; (o = re.exec(t)) != null; ) {
+          let r = o[1], s = o[2] || "";
+          s = s.trim();
+          let i = s[0];
+          s = s.replace(/^(['"`])([\s\S]*)\1$/mg, "$2"), i === '"' && (s = s.replace(/\\n/g, `
+`), s = s.replace(/\\r/g, "\r")), n[r] = s;
+        }
+        return n;
       }
-      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
-        return process.env.DOTENV_KEY;
+      function w(e) {
+        return e <= 32 ? e === 32 || e >= 9 && e <= 13 : e >= 160 && (e === 160 || e === 5760 || e >= 8192 && e <= 8202 || e === 8232 || e === 8233 || e === 8239 || e === 8287 || e === 12288 || e === 65279);
       }
-      return "";
-    }
-    function _instructions(result, dotenvKey) {
-      let uri;
-      try {
-        uri = new URL(dotenvKey);
-      } catch (error) {
-        if (error.code === "ERR_INVALID_URL") {
-          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
-          err.code = "INVALID_DOTENV_KEY";
-          throw err;
-        }
-        throw error;
-      }
-      const key = uri.password;
-      if (!key) {
-        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
-      }
-      const environment = uri.searchParams.get("environment");
-      if (!environment) {
-        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
-      }
-      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
-      const ciphertext = result.parsed[environmentKey];
-      if (!ciphertext) {
-        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
-        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
-        throw err;
-      }
-      return { ciphertext, key };
-    }
-    function _vaultPath(options) {
-      let possibleVaultPath = null;
-      if (options && options.path && options.path.length > 0) {
-        if (Array.isArray(options.path)) {
-          for (const filepath of options.path) {
-            if (fs7.existsSync(filepath)) {
-              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+      function q(e) {
+        return e === 10 || e === 8232 || e === 8233;
+      }
+      function oe(e) {
+        let n = {}, t = typeof e == "string" ? e : e.toString();
+        t.indexOf("\r") !== -1 && (t = t.replace(/\r\n?/g, `
+`));
+        let o = t.length, r = 0;
+        for (; r < o; ) {
+          let s = t.charCodeAt(r);
+          for (; r < o && w(s); ) r++, s = t.charCodeAt(r);
+          if (r >= o) break;
+          if (s === 35) {
+            for (; r < o && !q(t.charCodeAt(r)); ) r++;
+            continue;
+          }
+          let i = -1;
+          if (s === 101 && r + 6 < o && t.charCodeAt(r + 1) === 120 && t.charCodeAt(r + 2) === 112 && t.charCodeAt(r + 3) === 111 && t.charCodeAt(r + 4) === 114 && t.charCodeAt(r + 5) === 116) {
+            let v = t.charCodeAt(r + 6);
+            if (w(v)) {
+              let u = r + 7;
+              for (; u < o && w(t.charCodeAt(u)); ) u++;
+              b[t.charCodeAt(u)] && (i = r + 6, r = u);
+            } else s = t.charCodeAt(r);
+          }
+          let l = r, d = 0;
+          for (; r < o && (d = t.charCodeAt(r), b[d]); ) r++;
+          if (r === l) {
+            for (; r < o && !q(t.charCodeAt(r)); ) r++;
+            continue;
+          }
+          let h = t.slice(l, r), f = r;
+          if (r >= o && (d = 0), w(d)) do
+            r++, d = r < o ? t.charCodeAt(r) : 0;
+          while (w(d));
+          if (d === 61) r++;
+          else if (d === 58 && r === f && r + 1 < o && w(t.charCodeAt(r + 1))) r += 2;
+          else {
+            for (r = i === -1 ? f : i; r < o && !q(t.charCodeAt(r)); ) r++;
+            continue;
+          }
+          let c = r, a = r;
+          for (; a < o && w(t.charCodeAt(a)); ) a++;
+          let g = t.charCodeAt(a), p, y = false;
+          if (g === 39 || g === 34 || g === 96) {
+            let v = t[a], u = t.indexOf(v, a + 1), m = -1, C = -1;
+            for (; u !== -1; ) {
+              let O = t.charCodeAt(u - 1) === 92, E = u + 1;
+              for (; E < o && !q(t.charCodeAt(E)) && w(t.charCodeAt(E)); ) E++;
+              if ((E === o || q(t.charCodeAt(E)) || t.charCodeAt(E) === 35) && (m = u, C = E), !O) break;
+              u = t.indexOf(v, u + 1);
+            }
+            if (m !== -1) {
+              if (p = t.slice(a + 1, m), r = C, t.charCodeAt(r) === 35) for (; r < o && !q(t.charCodeAt(r)); ) r++;
+              y = true;
             }
           }
-        } else {
-          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+          if (!y) {
+            let v = t.indexOf(`
+`, c);
+            v === -1 && (v = o);
+            let u;
+            if (o < 4096) u = t.indexOf("#", c), (u === -1 || u > v) && (u = v);
+            else for (u = c; u < v && t.charCodeAt(u) !== 35; ) u++;
+            let m = c, C = u;
+            for (; m < C && w(t.charCodeAt(m)); ) m++;
+            for (; C > m && w(t.charCodeAt(C - 1)); ) C--;
+            let O = t.charCodeAt(m);
+            if (p = t.slice(m, C), p.includes("\u2028") || p.includes("\u2029") ? p = p.replace(/^(['"`])([\s\S]*)\1$/mg, "$2") : C - m >= 2 && (O === 39 || O === 34 || O === 96) && t.charCodeAt(C - 1) === O && (p = t.slice(m + 1, C - 1)), r = u, u < v) for (; r < o && !q(t.charCodeAt(r)); ) r++;
+          }
+          g === 34 && (y || a < r) && p.indexOf("\\") !== -1 && (p = p.replace(/\\n/g, `
+`).replace(/\\r/g, "\r")), n[h] = p;
         }
-      } else {
-        possibleVaultPath = path13.resolve(process.cwd(), ".env.vault");
+        return n;
       }
-      if (fs7.existsSync(possibleVaultPath)) {
-        return possibleVaultPath;
+      function se(e, n) {
+        return n && $(n.fast) ? oe(e) : ne(e);
       }
-      return null;
-    }
-    function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path13.join(os2.homedir(), envPath.slice(1)) : envPath;
-    }
-    function _configVault(options) {
-      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
-      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
-      if (debug || !quiet) {
-        _log("loading env from encrypted .env.vault");
-      }
-      const parsed = DotenvModule._parseVault(options);
-      let processEnv = process.env;
-      if (options && options.processEnv != null) {
-        processEnv = options.processEnv;
-      }
-      DotenvModule.populate(processEnv, parsed, options);
-      return { parsed };
-    }
-    function configDotenv(options) {
-      const dotenvPath = path13.resolve(process.cwd(), ".env");
-      let encoding = "utf8";
-      let processEnv = process.env;
-      if (options && options.processEnv != null) {
-        processEnv = options.processEnv;
-      }
-      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
-      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
-      if (options && options.encoding) {
-        encoding = options.encoding;
-      } else {
-        if (debug) {
-          _debug("no encoding is specified (UTF-8 is used by default)");
+      function T(e) {
+        console.log(`\u2506 ${e}`);
+      }
+      function ie(e) {
+        console.error(`\u25C7 ${e}`);
+      }
+      function V(e) {
+        return e[0] === "~" ? I.join(Z.homedir(), e.slice(1)) : e;
+      }
+      function ce(e = {}) {
+        let n = { ...e };
+        for (let t of Object.keys(n)) n[t] === void 0 && delete n[t];
+        return { ...B(), ...n };
+      }
+      function ae(e) {
+        e = ce(e);
+        let n = I.resolve(process.cwd(), ".env"), t = "utf8", o = process.env;
+        e && e.processEnv != null && (o = e.processEnv);
+        let r = $(e && e.debug);
+        e && e.encoding ? t = e.encoding : r && T("no encoding is specified (UTF-8 is used by default)");
+        let s = [n];
+        if (e && e.path) if (!Array.isArray(e.path)) s = [V(e.path)];
+        else {
+          s = [];
+          for (let c of e.path) s.push(V(c));
+        }
+        let i, l = {}, d = { fast: e.fast };
+        for (let c of s) try {
+          let a = A.parse(z.readFileSync(c, { encoding: t }), d);
+          A.populate(l, a, e);
+        } catch (a) {
+          r && T(`failed to load ${c} ${a.message}`), i = a;
+        }
+        let h = A.populate(o, l, e), f = $(Object.prototype.hasOwnProperty.call(e, "quiet") ? e.quiet : B(o).quiet);
+        if (r || !f) {
+          let c = Object.keys(h).length, a = [];
+          for (let g of s) try {
+            let p = I.relative(process.cwd(), g instanceof ee ? te(g) : g);
+            a.push(p);
+          } catch (p) {
+            r && T(`failed to load ${g} ${p.message}`), i = p;
+          }
+          ie(`injected env (${c}) from ${a.join(",")}`);
         }
+        return i ? { parsed: l, error: i } : { parsed: l };
       }
-      let optionPaths = [dotenvPath];
-      if (options && options.path) {
-        if (!Array.isArray(options.path)) {
-          optionPaths = [_resolveHome(options.path)];
-        } else {
-          optionPaths = [];
-          for (const filepath of options.path) {
-            optionPaths.push(_resolveHome(filepath));
+      function le(e) {
+        return A.configDotenv(e);
+      }
+      function fe(e, n, t = {}) {
+        let o = $(t && t.debug), r = $(t && t.override), s = {};
+        if (e === null || typeof e != "object" || n === null || typeof n != "object") {
+          let i = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+          throw i.code = "OBJECT_REQUIRED", i;
+        }
+        for (let i of Object.keys(n)) Object.prototype.hasOwnProperty.call(e, i) ? (r === true && (e[i] = n[i], s[i] = n[i]), o && T(r === true ? `"${i}" is already defined and WAS overwritten` : `"${i}" is already defined and was NOT overwritten`)) : (e[i] = n[i], s[i] = n[i]);
+        return s;
+      }
+      var A = { configDotenv: ae, config: le, parse: se, populate: fe };
+      x.exports.configDotenv = A.configDotenv;
+      x.exports.config = A.config;
+      x.exports.parse = A.parse;
+      x.exports.populate = A.populate;
+      x.exports = A;
+    });
+    var M = j((Te, W) => {
+      var _ = __require("child_process"), ue = __require("fs"), L = __require("path");
+      function de(e) {
+        let n = ['"'], t = 0;
+        for (let o of e) {
+          if (o === "\\") {
+            t++;
+            continue;
           }
+          o === '"' ? n.push("\\".repeat(t * 2 + 1), '"') : n.push("\\".repeat(t), o), t = 0;
         }
+        return n.push("\\".repeat(t * 2), '"'), n.join("");
       }
-      let lastError;
-      const parsedAll = {};
-      for (const path14 of optionPaths) {
-        try {
-          const parsed = DotenvModule.parse(fs7.readFileSync(path14, { encoding }));
-          DotenvModule.populate(parsedAll, parsed, options);
-        } catch (e) {
-          if (debug) {
-            _debug(`failed to load ${path14} ${e.message}`);
-          }
-          lastError = e;
-        }
-      }
-      const populated = DotenvModule.populate(processEnv, parsedAll, options);
-      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
-      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
-      if (debug || !quiet) {
-        const keysCount = Object.keys(populated).length;
-        const shortPaths = [];
-        for (const filePath of optionPaths) {
-          try {
-            const relative2 = path13.relative(process.cwd(), filePath);
-            shortPaths.push(relative2);
-          } catch (e) {
-            if (debug) {
-              _debug(`failed to load ${filePath} ${e.message}`);
-            }
-            lastError = e;
+      function H(e, n = 1) {
+        for (let t = 0; t < n; t++) {
+          let o = [];
+          for (let r of e) {
+            let s = r.charCodeAt(0), i = s >= 48 && s <= 57 || s >= 65 && s <= 90 || s >= 97 && s <= 122, l = "\\/:._-".includes(r);
+            !i && !l && s < 128 && o.push("^"), o.push(r);
           }
+          e = o.join("");
         }
-        _log(`injected env (${keysCount}) from ${shortPaths.join(",")} ${dim(`// tip: ${_getRandomTip()}`)}`);
+        return e;
       }
-      if (lastError) {
-        return { parsed: parsedAll, error: lastError };
-      } else {
-        return { parsed: parsedAll };
+      function P(e, n) {
+        let t = Object.keys(e).reverse().find((o) => o.toUpperCase() === n);
+        return t === void 0 ? void 0 : e[t];
       }
-    }
-    function config(options) {
-      if (_dotenvKey(options).length === 0) {
-        return DotenvModule.configDotenv(options);
+      function pe(e, n, t) {
+        let o = (P(n, "PATHEXT") || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean), s = o.some((l) => e.toLowerCase().endsWith(l.toLowerCase())) ? ["", ...o] : [...o, ""], i = /[\\/]/.test(e) ? [t] : [t, ...(P(n, "PATH") || "").split(";")];
+        for (let l of i) for (let d of s) {
+          let h = L.resolve(t, l.replace(/^"|"$/g, ""), e + d);
+          try {
+            if (ue.statSync(h).isFile()) return h;
+          } catch {
+          }
+        }
       }
-      const vaultPath = _vaultPath(options);
-      if (!vaultPath) {
-        _warn(`you set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}`);
-        return DotenvModule.configDotenv(options);
+      function he(e, n, t) {
+        if (process.platform !== "win32") return _.spawn(e, n, t);
+        let o = t.env || process.env, r = pe(e, o, t.cwd || process.cwd());
+        if (r && /\.(?:exe|com)$/i.test(r)) return _.spawn(r, n, t);
+        let s = /\.(?:bat|cmd)$/i.test(r || e), i = [H(L.normalize(r || e))];
+        for (let d of n) i.push(H(de(d), s ? 2 : 1));
+        let l = i.join(" ");
+        return _.spawn(P(o, "COMSPEC") || "cmd.exe", ["/d", "/v:off", "/s", "/c", `"${l}"`], { ...t, windowsVerbatimArguments: true });
       }
-      return DotenvModule._configVault(options);
-    }
-    function decrypt(encrypted, keyStr) {
-      const key = Buffer.from(keyStr.slice(-64), "hex");
-      let ciphertext = Buffer.from(encrypted, "base64");
-      const nonce = ciphertext.subarray(0, 12);
-      const authTag = ciphertext.subarray(-16);
-      ciphertext = ciphertext.subarray(12, -16);
-      try {
-        const aesgcm = crypto2.createDecipheriv("aes-256-gcm", key, nonce);
-        aesgcm.setAuthTag(authTag);
-        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
-      } catch (error) {
-        const isRange = error instanceof RangeError;
-        const invalidKeyLength = error.message === "Invalid key length";
-        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
-        if (isRange || invalidKeyLength) {
-          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
-          err.code = "INVALID_DOTENV_KEY";
-          throw err;
-        } else if (decryptionFailed) {
-          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
-          err.code = "DECRYPTION_FAILED";
-          throw err;
-        } else {
-          throw error;
+      W.exports = he;
+    });
+    var X = j(($e, F) => {
+      var ge = __require("fs"), me = __require("os"), Q = __require("path"), ve = __require("child_process"), Ce = M(), R = N(), { optionsFromEnv: J } = k();
+      function D() {
+        console.log(["Usage: dotenv run [--help] [-q|--quiet] [--debug] [--override] [--fast] [-f|--file <paths>] [--] <command> [args...]", "", "Run a command with environment variables from a .env file.", "Place dotenv options before the command; all following arguments go to the command.", "", "Options:", "  -f, --file <paths>  .env paths, comma-separated or repeated (default: .env)", "  -q, --quiet suppress the injected env message", "  --debug     enable debug logging", "  --override  override existing environment variables", "  --fast      use the faster character-scanner parser", "", "Environment variables (DOTENV_CONFIG_* names remain as fallbacks):", "  DOTENV_PATH, DOTENV_ENCODING, DOTENV_QUIET,", "  DOTENV_DEBUG, DOTENV_OVERRIDE,", "  DOTENV_FAST"].join(`
+`));
+      }
+      function we(e) {
+        let n = [], t = false, o, r, s, i, l = -1;
+        for (let h = 0; h < e.length; h++) {
+          let f = e[h];
+          if (f === "--") {
+            l = h + 1;
+            break;
+          }
+          if (f === "--help" || f === "-h") return { help: true };
+          if (f === "--quiet" || f === "-q") {
+            o = true;
+            continue;
+          }
+          if (f === "--debug") {
+            r = true;
+            continue;
+          }
+          if (f === "--override") {
+            s = true;
+            continue;
+          }
+          if (f === "--fast") {
+            i = true;
+            continue;
+          }
+          if (f === "-f" || f === "--file" || f.startsWith("-f=") || f.startsWith("--file=")) {
+            let c = f.indexOf("="), a = c === -1 ? f : f.slice(0, c), g = c === -1 ? e[++h] : f.slice(c + 1);
+            if (!g || g === "--") return { error: `${a} requires a path` };
+            let p = g.split(",").map((y) => y.trim()).filter(Boolean);
+            if (p.length === 0) return { error: `${a} requires a path` };
+            n.push(...p), t = true;
+            continue;
+          }
+          if (f.startsWith("-")) return { error: `unknown option: ${f}` };
+          l = h;
+          break;
         }
+        let d = l === -1 ? [] : e.slice(l);
+        return { paths: n, pathSet: t, quiet: o, debug: r, override: s, fast: i, command: d };
       }
-    }
-    function populate(processEnv, parsed, options = {}) {
-      const debug = Boolean(options && options.debug);
-      const override = Boolean(options && options.override);
-      const populated = {};
-      if (typeof parsed !== "object") {
-        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
-        err.code = "OBJECT_REQUIRED";
-        throw err;
+      function Ae(e) {
+        return e[0] === "~" ? Q.join(me.homedir(), e.slice(1)) : e;
       }
-      for (const key of Object.keys(parsed)) {
-        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
-          if (override === true) {
-            processEnv[key] = parsed[key];
-            populated[key] = parsed[key];
+      function Ee(e) {
+        let n = J(), t = { encoding: n.encoding || "utf8", quiet: n.quiet, debug: n.debug === true, override: n.override === true, fast: n.fast === true, paths: [".env"], defaultPath: true };
+        return n.path != null && (t.paths = [n.path], t.defaultPath = false), e.pathSet && (t.paths = e.paths, t.defaultPath = false), e.quiet != null && (t.quiet = e.quiet), e.debug != null && (t.debug = e.debug), e.override != null && (t.override = e.override), e.fast != null && (t.fast = e.fast), t;
+      }
+      function be(e) {
+        let n = {}, t = [], o = { override: e.override, debug: e.debug };
+        for (let s of e.paths) {
+          let i = Q.resolve(process.cwd(), Ae(s));
+          try {
+            let l = R.parse(ge.readFileSync(i, { encoding: e.encoding }), { fast: e.fast });
+            R.populate(n, l, o), t.push(s);
+          } catch (l) {
+            if (e.debug && console.log(`\u2506 failed to load ${s} ${l.message}`), !(e.defaultPath && l.code === "ENOENT")) throw l;
           }
-          if (debug) {
-            if (override === true) {
-              _debug(`"${key}" is already defined and WAS overwritten`);
-            } else {
-              _debug(`"${key}" is already defined and was NOT overwritten`);
+        }
+        return { injected: R.populate(process.env, n, o), loadedPaths: t };
+      }
+      function K(e) {
+        let n = e[0];
+        if (n === "--help" || n === "-h") {
+          D();
+          return;
+        }
+        if (n !== "run") {
+          D(), process.exitCode = 1;
+          return;
+        }
+        let t = we(e.slice(1));
+        if (t.help) {
+          D();
+          return;
+        }
+        if (t.error) {
+          console.error(`dotenv: ${t.error}`), D(), process.exitCode = 1;
+          return;
+        }
+        if (t.command.length === 0) {
+          D(), process.exitCode = 1;
+          return;
+        }
+        let o = Ee(t);
+        try {
+          let c = be(o);
+          if (!(o.quiet == null ? J().quiet : o.quiet)) {
+            let g = `\u25C7 injected env (${Object.keys(c.injected).length})`;
+            c.loadedPaths.length > 0 && (g += ` from ${c.loadedPaths.join(", ")}`), console.error(g);
+          }
+        } catch (c) {
+          console.error(`dotenv: ${c.message}`), process.exitCode = 1;
+          return;
+        }
+        let r = !!process.stdin.isTTY, s = process.platform !== "win32" && !r, i = Ce(t.command[0], t.command.slice(1), { stdio: "inherit", detached: s }), l = /* @__PURE__ */ new Map(), d = 0;
+        function h(c) {
+          if (!(!i.pid || i.exitCode !== null || i.signalCode !== null)) {
+            if (process.platform === "win32") {
+              ve.spawnSync("taskkill", ["/pid", String(i.pid), "/T", "/F"], { stdio: "ignore" });
+              return;
+            }
+            try {
+              process.kill(s ? -i.pid : i.pid, c);
+            } catch (a) {
+              if (a.code !== "ESRCH") throw a;
             }
           }
-        } else {
-          processEnv[key] = parsed[key];
-          populated[key] = parsed[key];
         }
+        function f() {
+          for (let [c, a] of l) process.removeListener(c, a);
+        }
+        for (let c of ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"]) {
+          let a = () => {
+            if (c === "SIGINT") {
+              if (d++, r && process.platform !== "win32" && d === 1) return;
+              if (d > 1) {
+                h(d === 2 ? "SIGTERM" : "SIGKILL");
+                return;
+              }
+            }
+            h(c);
+          };
+          l.set(c, a), process.on(c, a);
+        }
+        i.on("error", function(c) {
+          f(), console.error(`dotenv: ${c.message}`), process.exitCode = 1;
+        }), i.on("exit", function(c, a) {
+          f(), typeof c == "number" ? process.exit(c) : (setInterval(() => {
+          }, 1e3), process.kill(process.pid, a));
+        });
       }
-      return populated;
-    }
-    var DotenvModule = {
-      configDotenv,
-      _configVault,
-      _parseVault,
-      config,
-      decrypt,
-      parse,
-      populate
-    };
-    module.exports.configDotenv = DotenvModule.configDotenv;
-    module.exports._configVault = DotenvModule._configVault;
-    module.exports._parseVault = DotenvModule._parseVault;
-    module.exports.config = DotenvModule.config;
-    module.exports.decrypt = DotenvModule.decrypt;
-    module.exports.parse = DotenvModule.parse;
-    module.exports.populate = DotenvModule.populate;
-    module.exports = DotenvModule;
+      F.exports = K;
+      __require.main === F && K(process.argv.slice(2));
+    });
+    var S = N();
+    var qe = X();
+    module.exports = S;
+    module.exports.config = S.config;
+    module.exports.configDotenv = S.configDotenv;
+    module.exports.parse = S.parse;
+    module.exports.populate = S.populate;
+    __require.main === module && qe(process.argv.slice(2));
   }
 });
 
@@ -431,17 +504,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path13) {
-      const ctrl = callVisitor(key, node, visitor, path13);
+    function visit_(key, node, visitor, path14) {
+      const ctrl = callVisitor(key, node, visitor, path14);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path13, ctrl);
-        return visit_(key, ctrl, visitor, path13);
+        replaceNode(key, path14, ctrl);
+        return visit_(key, ctrl, visitor, path14);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path13 = Object.freeze(path13.concat(node));
+          path14 = Object.freeze(path14.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path13);
+            const ci = visit_(i, node.items[i], visitor, path14);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -452,13 +525,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path13 = Object.freeze(path13.concat(node));
-          const ck = visit_("key", node.key, visitor, path13);
+          path14 = Object.freeze(path14.concat(node));
+          const ck = visit_("key", node.key, visitor, path14);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path13);
+          const cv = visit_("value", node.value, visitor, path14);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -479,17 +552,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path13) {
-      const ctrl = await callVisitor(key, node, visitor, path13);
+    async function visitAsync_(key, node, visitor, path14) {
+      const ctrl = await callVisitor(key, node, visitor, path14);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path13, ctrl);
-        return visitAsync_(key, ctrl, visitor, path13);
+        replaceNode(key, path14, ctrl);
+        return visitAsync_(key, ctrl, visitor, path14);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path13 = Object.freeze(path13.concat(node));
+          path14 = Object.freeze(path14.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path13);
+            const ci = await visitAsync_(i, node.items[i], visitor, path14);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -500,13 +573,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path13 = Object.freeze(path13.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path13);
+          path14 = Object.freeze(path14.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path14);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path13);
+          const cv = await visitAsync_("value", node.value, visitor, path14);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -533,23 +606,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path13) {
+    function callVisitor(key, node, visitor, path14) {
       if (typeof visitor === "function")
-        return visitor(key, node, path13);
+        return visitor(key, node, path14);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path13);
+        return visitor.Map?.(key, node, path14);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path13);
+        return visitor.Seq?.(key, node, path14);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path13);
+        return visitor.Pair?.(key, node, path14);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path13);
+        return visitor.Scalar?.(key, node, path14);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path13);
+        return visitor.Alias?.(key, node, path14);
       return void 0;
     }
-    function replaceNode(key, path13, node) {
-      const parent = path13[path13.length - 1];
+    function replaceNode(key, path14, node) {
+      const parent = path14[path14.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -1161,10 +1234,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path13, value) {
+    function collectionFromPath(schema, path14, value) {
       let v = value;
-      for (let i = path13.length - 1; i >= 0; --i) {
-        const k = path13[i];
+      for (let i = path14.length - 1; i >= 0; --i) {
+        const k = path14[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -1183,7 +1256,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path13) => path13 == null || typeof path13 === "object" && !!path13[Symbol.iterator]().next().done;
+    var isEmptyPath = (path14) => path14 == null || typeof path14 === "object" && !!path14[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -1213,11 +1286,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path13, value) {
-        if (isEmptyPath(path13))
+      addIn(path14, value) {
+        if (isEmptyPath(path14))
           this.add(value);
         else {
-          const [key, ...rest] = path13;
+          const [key, ...rest] = path14;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -1231,8 +1304,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path13) {
-        const [key, ...rest] = path13;
+      deleteIn(path14) {
+        const [key, ...rest] = path14;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -1246,8 +1319,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path13, keepScalar) {
-        const [key, ...rest] = path13;
+      getIn(path14, keepScalar) {
+        const [key, ...rest] = path14;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -1265,8 +1338,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path13) {
-        const [key, ...rest] = path13;
+      hasIn(path14) {
+        const [key, ...rest] = path14;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -1276,8 +1349,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path13, value) {
-        const [key, ...rest] = path13;
+      setIn(path14, value) {
+        const [key, ...rest] = path14;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3792,9 +3865,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path13, value) {
+      addIn(path14, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path13, value);
+          this.contents.addIn(path14, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3869,14 +3942,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path13) {
-        if (Collection.isEmptyPath(path13)) {
+      deleteIn(path14) {
+        if (Collection.isEmptyPath(path14)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path13) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path14) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3891,10 +3964,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path13, keepScalar) {
-        if (Collection.isEmptyPath(path13))
+      getIn(path14, keepScalar) {
+        if (Collection.isEmptyPath(path14))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path13, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path14, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3905,10 +3978,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path13) {
-        if (Collection.isEmptyPath(path13))
+      hasIn(path14) {
+        if (Collection.isEmptyPath(path14))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path13) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path14) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3925,13 +3998,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path13, value) {
-        if (Collection.isEmptyPath(path13)) {
+      setIn(path14, value) {
+        if (Collection.isEmptyPath(path14)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path13), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path14), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path13, value);
+          this.contents.setIn(path14, value);
         }
       }
       /**
@@ -5892,9 +5965,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path13) => {
+    visit.itemAtPath = (cst, path14) => {
       let item = cst;
-      for (const [field, index] of path13) {
+      for (const [field, index] of path14) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5903,23 +5976,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path13) => {
-      const parent = visit.itemAtPath(cst, path13.slice(0, -1));
-      const field = path13[path13.length - 1][0];
+    visit.parentCollection = (cst, path14) => {
+      const parent = visit.itemAtPath(cst, path14.slice(0, -1));
+      const field = path14[path14.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path13, item, visitor) {
-      let ctrl = visitor(item, path13);
+    function _visit(path14, item, visitor) {
+      let ctrl = visitor(item, path14);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path13.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path14.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5930,10 +6003,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path13);
+            ctrl = ctrl(item, path14);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path13) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path14) : ctrl;
     }
     exports.visit = visit;
   }
@@ -7235,14 +7308,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs7 = this.flowScalar(this.type);
+              const fs8 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs7, sep: [] });
+                map.items.push({ start, key: fs8, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs7);
+                this.stack.push(fs8);
               } else {
-                Object.assign(it, { key: fs7, sep: [] });
+                Object.assign(it, { key: fs8, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7370,13 +7443,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs7 = this.flowScalar(this.type);
+              const fs8 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs7, sep: [] });
+                fc.items.push({ start: [], key: fs8, sep: [] });
               else if (it.sep)
-                this.stack.push(fs7);
+                this.stack.push(fs8);
               else
-                Object.assign(it, { key: fs7, sep: [] });
+                Object.assign(it, { key: fs8, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7633,7 +7706,7 @@ var require_public_api = __commonJS({
 });
 
 // ../../node_modules/yaml/dist/index.js
-var require_dist = __commonJS({
+var require_dist2 = __commonJS({
   "../../node_modules/yaml/dist/index.js"(exports) {
     "use strict";
     var composer = require_composer();
@@ -7856,7 +7929,7 @@ function getAtPath(obj, dottedKey) {
 }
 
 // ../configuration-core/src/secrets.ts
-var import_dotenv = __toESM(require_main(), 1);
+var import_dotenv = __toESM(require_dist(), 1);
 import * as fs3 from "node:fs";
 import * as path4 from "node:path";
 
@@ -8002,7 +8075,7 @@ var CONFIG_SCHEMA = [
   // nominal here — the project scope of a global-only key is never read.
   {
     key: "scripts.maxTimeoutMs",
-    description: `Upper bound, in milliseconds, on the time limit a flow \`script\` step may ask for (default 300000 \u2014 five minutes). Bounds how long one script can occupy the host. Values below ${MIN_SCRIPT_TIMEOUT_MS} ms are refused: the step starts a Node process before the script runs, so a smaller ceiling ends a script that did nothing wrong.`,
+    description: `Upper bound, in milliseconds, on the time limit an e2e test \`script\` step may ask for (default 300000 \u2014 five minutes). Bounds how long one script can occupy the host. Values below ${MIN_SCRIPT_TIMEOUT_MS} ms are refused: the step starts a Node process before the script runs, so a smaller ceiling ends a script that did nothing wrong.`,
     scopes: ["global"],
     parse: (raw) => {
       const value = asPositiveInteger(raw);
@@ -8015,7 +8088,7 @@ var CONFIG_SCHEMA = [
   },
   {
     key: "scripts.heapLimitMb",
-    description: `Old-space heap limit, in MiB, given to each flow \`script\` process (default 512). Values below ${MIN_SCRIPT_HEAP_LIMIT_MB} MiB are refused: that is already below what importing a real npm dependency needs, and under about 5 MiB the process dies inside V8's own startup before any script runs.`,
+    description: `Old-space heap limit, in MiB, given to each e2e test \`script\` process (default 512). Values below ${MIN_SCRIPT_HEAP_LIMIT_MB} MiB are refused: that is already below what importing a real npm dependency needs, and under about 5 MiB the process dies inside V8's own startup before any script runs.`,
     scopes: ["global"],
     parse: (raw) => {
       const value = asPositiveInteger(raw);
@@ -8100,7 +8173,7 @@ function generateToken() {
   return randomBytes(AUTH_TOKEN_BYTES).toString("hex");
 }
 function findFreePort() {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const srv = net.createServer();
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
@@ -8111,7 +8184,7 @@ function findFreePort() {
       const port = addr.port;
       srv.close((err) => {
         if (err) reject(err);
-        else resolve8(port);
+        else resolve9(port);
       });
     });
     srv.on("error", reject);
@@ -8209,7 +8282,7 @@ function killSpawnedChild(child, pid) {
   }
 }
 function spawnToolsServer(paths, port, options = {}) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     let logFd;
     try {
       fs4.mkdirSync(STATE_DIR, { recursive: true });
@@ -8255,7 +8328,7 @@ function spawnToolsServer(paths, port, options = {}) {
         rl.close();
         child.stdout?.resume();
         child.stdout?.unref?.();
-        settle(() => resolve8({ port: actualPort, pid }));
+        settle(() => resolve9({ port: actualPort, pid }));
       }
     });
     child.on("error", (err) => {
@@ -8560,10 +8633,11 @@ async function ensureToolsServer(paths) {
 }
 
 // ../argent-tools-client/src/tools-client.ts
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 
 // ../registry/src/types.ts
 var LINKED_CALL_HEADER = "x-argent-linked";
+var E2E_DIR_CLIENT_HEADER = "x-argent-e2e-dir";
 
 // ../registry/src/artifacts.ts
 import { stat } from "node:fs/promises";
@@ -8601,19 +8675,95 @@ function toolStepFiles(specs, args) {
   }
   return files;
 }
-function isClientFileArgument({ spec, path: path13 }) {
-  return spec.kind === "file" && spec.path === `\${${spec.target}}` && path13.startsWith("/") && hasToolFileExtension(path13);
+function isClientFileArgument({ spec, path: path14 }) {
+  return spec.kind === "file" && spec.path === `\${${spec.target}}` && path14.startsWith("/") && hasToolFileExtension(path14);
 }
 
 // ../registry/src/flow-file-refs.ts
+import * as fs6 from "node:fs/promises";
+import * as path8 from "node:path";
+
+// ../registry/src/e2e-dirs.ts
 import * as fs5 from "node:fs/promises";
 import * as path7 from "node:path";
+var E2E_DIR = path7.join(".argent", "e2e");
+var LEGACY_E2E_DIRS = Object.freeze([path7.join(".argent", "flows")]);
+var E2E_DIRS = Object.freeze([E2E_DIR, ...LEGACY_E2E_DIRS]);
+function e2eDirFor(projectRoot) {
+  return path7.join(projectRoot, E2E_DIR);
+}
+function e2eDirsFor(projectRoot) {
+  return E2E_DIRS.map((dir) => path7.join(projectRoot, dir));
+}
+function e2eFileCandidates(projectRoot, name) {
+  return e2eDirsFor(projectRoot).map((dir) => path7.join(dir, `${name}.yaml`));
+}
+async function exists(file) {
+  return fs5.stat(file).then(
+    () => true,
+    () => false
+  );
+}
+async function pickE2eFile(candidates) {
+  for (let i = 0; i < candidates.length; i++) {
+    if (!await exists(candidates[i])) continue;
+    let shadowed;
+    for (const later of candidates.slice(i + 1)) {
+      if (await exists(later)) {
+        shadowed = later;
+        break;
+      }
+    }
+    return {
+      path: candidates[i],
+      exists: true,
+      legacy: i > 0,
+      ...shadowed === void 0 ? {} : { shadowed }
+    };
+  }
+  return { path: candidates[0], exists: false, legacy: false };
+}
+function e2eShadowWarning(used, shadowed) {
+  return `${shadowed} is not used: ${used} has the same name and is read first.`;
+}
+var E2E_DIR_NAMES = E2E_DIRS.map((dir) => path7.basename(dir));
+function e2eDirProject(dir) {
+  const trimmed = dir.length > 1 ? dir.replace(/[\\/]+$/, "") : dir;
+  const argent = path7.dirname(trimmed);
+  if (!E2E_DIR_NAMES.includes(path7.basename(trimmed)) || path7.basename(argent) !== ".argent") {
+    return null;
+  }
+  return path7.dirname(argent);
+}
+function e2eRunFallbackDirs(anchorDir, target) {
+  if (target.includes("/") || target.includes("\\")) return [];
+  const project = e2eDirProject(anchorDir);
+  if (project === null) return [];
+  const anchor = path7.resolve(anchorDir);
+  return e2eDirsFor(project).filter((dir) => path7.resolve(dir) !== anchor);
+}
+
+// ../registry/src/tool-ids.ts
+var TOOL_ID_ALIASES = Object.freeze({
+  "flow-start-recording": "e2e-start-recording",
+  "flow-add-step": "e2e-add-step",
+  "flow-add-echo": "e2e-add-echo",
+  "flow-add-script": "e2e-add-script",
+  "flow-finish-recording": "e2e-finish-recording",
+  "flow-read-prerequisite": "e2e-read-prerequisite",
+  "flow-execute": "e2e-execute"
+});
+function canonicalToolId(id) {
+  return Object.hasOwn(TOOL_ID_ALIASES, id) ? TOOL_ID_ALIASES[id] : id;
+}
+
+// ../registry/src/flow-file-refs.ts
 async function canonicalFlowPath(p) {
   try {
-    return await fs5.realpath(p);
+    return await fs6.realpath(p);
   } catch {
     try {
-      return path7.join(await fs5.realpath(path7.dirname(p)), path7.basename(p));
+      return path8.join(await fs6.realpath(path8.dirname(p)), path8.basename(p));
     } catch {
       return p;
     }
@@ -8622,7 +8772,7 @@ async function canonicalFlowPath(p) {
 function completeRunExtension(value) {
   if (value.endsWith(".yaml")) return value;
   const candidate = `${value}.yaml`;
-  return FLOW_FILE_NAME_PATTERN.test(path7.posix.basename(candidate)) ? candidate : value;
+  return FLOW_FILE_NAME_PATTERN.test(path8.posix.basename(candidate)) ? candidate : value;
 }
 var MAX_RUN_DEPTH = 20;
 var MAX_BLOCK_NESTING = 64;
@@ -8641,16 +8791,16 @@ function collectFlowRequests(doc) {
     for (const step of steps) {
       if (!isRecord(step)) continue;
       const run = step.run;
-      if (typeof run === "string" && !run.includes("\\") && !path7.posix.isAbsolute(run) && !/^[A-Za-z]:/.test(run)) {
+      if (typeof run === "string" && !run.includes("\\") && !path8.posix.isAbsolute(run) && !/^[A-Za-z]:/.test(run)) {
         const target = completeRunExtension(run);
-        if (FLOW_FILE_NAME_PATTERN.test(path7.posix.basename(target))) runTargets.add(target);
+        if (FLOW_FILE_NAME_PATTERN.test(path8.posix.basename(target))) runTargets.add(target);
       }
       const snapshot = isRecord(step.snapshot) ? step.snapshot.name : step.snapshot;
       if (typeof snapshot === "string" && FLOW_NAME_PATTERN.test(snapshot)) snapshots.add(snapshot);
       if (typeof step.tool === "string") {
         const args = isRecord(step.args) ? step.args : {};
         toolSteps.push({ tool: step.tool, args });
-        const target = step.tool === "flow-execute" ? nestedFlowTarget(args) : void 0;
+        const target = canonicalToolId(step.tool) === "e2e-execute" ? nestedFlowTarget(args) : void 0;
         if (target !== void 0) nested.push({ target, args });
       }
       visit(step.steps, depth + 1);
@@ -8660,14 +8810,14 @@ function collectFlowRequests(doc) {
   return { runTargets: [...runTargets], snapshots: [...snapshots], toolSteps, nested };
 }
 function baselineKeyFor(canonicalPath, flowName) {
-  const stem = path7.basename(canonicalPath, ".yaml");
+  const stem = path8.basename(canonicalPath, ".yaml");
   return FLOW_NAME_PATTERN.test(stem) ? stem : flowName;
 }
 function flowMemberKey(anchorDir, target) {
   return `${anchorDir}\0${target}`;
 }
 async function classifyOnDiskSpelling(dir, base, addressable = FLOW_FILE_NAME_PATTERN) {
-  const entries = await fs5.readdir(dir).catch(() => null);
+  const entries = await fs6.readdir(dir).catch(() => null);
   if (entries === null || entries.includes(base)) return { state: "listed" };
   const actual = entries.find((entry) => entry.toLowerCase() === base.toLowerCase());
   if (actual === void 0) return { state: "absent" };
@@ -8679,19 +8829,15 @@ function nestedFlowTarget(args) {
   if (flowPath === void 0) {
     if (typeof name !== "string" || !FLOW_NAME_PATTERN.test(name)) return void 0;
     if (!isResolvedAbsolute(projectRoot)) return void 0;
-    return {
-      kind: "name",
-      projectRoot,
-      name,
-      path: path7.join(projectRoot, ".argent", "flows", `${name}.yaml`)
-    };
+    const paths = e2eFileCandidates(projectRoot, name);
+    return { kind: "name", projectRoot, name, path: paths[0], paths };
   }
   if (name !== void 0 || !isResolvedAbsolute(flowPath)) return void 0;
-  if (!FLOW_FILE_NAME_PATTERN.test(path7.basename(flowPath))) return void 0;
+  if (!FLOW_FILE_NAME_PATTERN.test(path8.basename(flowPath))) return void 0;
   return { kind: "flow_path", path: flowPath };
 }
 function isResolvedAbsolute(value) {
-  return typeof value === "string" && path7.isAbsolute(value) && !value.split(/[\\/]+/).includes("..");
+  return typeof value === "string" && path8.isAbsolute(value) && !value.split(/[\\/]+/).includes("..");
 }
 
 // ../registry/src/failure-codes.ts
@@ -8811,6 +8957,11 @@ var FAILURE_CODES = {
   // a device that is not foldable, no hinge route, a remote simulator.
   IOS_FOLD_FAILED: "IOS_FOLD_FAILED",
   IOS_FOLD_UNSUPPORTED: "IOS_FOLD_UNSUPPORTED",
+  // The hinge of a foldable Android emulator: the console refused the move or
+  // the guest never committed the state vs. nothing to fold — a phone profile,
+  // a physical device.
+  ANDROID_FOLD_FAILED: "ANDROID_FOLD_FAILED",
+  ANDROID_FOLD_UNSUPPORTED: "ANDROID_FOLD_UNSUPPORTED",
   PASTE_CLIPBOARD_SET_FAILED: "PASTE_CLIPBOARD_SET_FAILED",
   PASTE_CLIPBOARD_UNSUPPORTED: "PASTE_CLIPBOARD_UNSUPPORTED",
   SETTINGS_PERMISSION_UNSUPPORTED: "SETTINGS_PERMISSION_UNSUPPORTED",
@@ -9016,9 +9167,9 @@ var FAILURE_SPAWN_CODE_SET = new Set(FAILURE_SPAWN_CODES);
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 var resolvedDuringInvocation = new AsyncLocalStorage();
-function valueAtPath(root, path13) {
+function valueAtPath(root, path14) {
   let current = root;
-  for (const key of path13) {
+  for (const key of path14) {
     if (current === null || typeof current !== "object") return void 0;
     if (!Object.hasOwn(current, key)) return void 0;
     current = current[key];
@@ -9076,11 +9227,11 @@ function describeParamIssues(error, params) {
 }
 
 // ../argent-tools-client/src/link-config.ts
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile2, unlink as unlink2, chmod as chmod2 } from "node:fs/promises";
-var LINK_DIR = path8.join(homedir4(), ".argent");
-var LINK_FILE = path8.join(LINK_DIR, "link.json");
+var LINK_DIR = path9.join(homedir4(), ".argent");
+var LINK_FILE = path9.join(LINK_DIR, "link.json");
 async function readLinkConfig() {
   try {
     const raw = await readFile2(LINK_FILE, "utf8");
@@ -9129,22 +9280,22 @@ import {
   realpath as realpath2,
   rename as rename2,
   rm as rm2,
-  stat as stat2,
+  stat as stat3,
   writeFile as writeFile3
 } from "node:fs/promises";
 import { constants, tmpdir } from "node:os";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 
 // ../archive/src/index.ts
 import { execFile } from "node:child_process";
 import { rm, readdir as readdir3 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname4, join as join8, posix as posix2, resolve as resolve5, sep as sep2 } from "node:path";
+import { basename as basename4, dirname as dirname5, join as join9, posix as posix2, resolve as resolve6, sep as sep2 } from "node:path";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
 var ArchiveError = class extends Error {
 };
 function createTarGzArgs(sourcePath, target) {
-  return ["-czf", target, "-C", dirname4(sourcePath), basename3(sourcePath)];
+  return ["-czf", target, "-C", dirname5(sourcePath), basename4(sourcePath)];
 }
 async function createTarGzFile(sourcePath, tarPath) {
   try {
@@ -9166,8 +9317,8 @@ function isSafeTarMember(memberPath, destDir) {
   if (relative2 === ".." || relative2.startsWith("../") || relative2.split("/").includes("..")) {
     return false;
   }
-  const root = resolve5(destDir);
-  const resolved = resolve5(destDir, relative2);
+  const root = resolve6(destDir);
+  const resolved = resolve6(destDir, relative2);
   return resolved === root || resolved.startsWith(root + sep2);
 }
 async function listTarMembers(tarPath) {
@@ -9221,7 +9372,7 @@ async function assertSafeArchive(tarPath, destDir) {
 async function resolveMember(destDir, expectedName) {
   const entries = await readdir3(destDir);
   if (entries.includes(expectedName)) {
-    return join8(destDir, expectedName);
+    return join9(destDir, expectedName);
   }
   const real = entries.filter((e) => !e.startsWith("._"));
   if (real.length !== 1) {
@@ -9229,7 +9380,7 @@ async function resolveMember(destDir, expectedName) {
       `Could not identify the extracted member (expected "${expectedName}", found ${real.length} entries).`
     );
   }
-  return join8(destDir, real[0]);
+  return join9(destDir, real[0]);
 }
 async function safeExtractTarGz(tarPath, destDir, expectedName) {
   await assertSafeArchive(tarPath, destDir);
@@ -9267,6 +9418,16 @@ function interpolatePath(template, args) {
   });
   return missing ? null : out;
 }
+async function specPath(spec, args) {
+  if (spec.kind !== "file" || !spec.paths?.length) return interpolatePath(spec.path, args);
+  const candidates = [];
+  for (const template of spec.paths) {
+    const filled = interpolatePath(template, args);
+    if (filled === null) return null;
+    candidates.push(filled);
+  }
+  return (await pickE2eFile(candidates)).path;
+}
 var pendingArchives = /* @__PURE__ */ new Set();
 var ARCHIVE_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
 function removePendingArchives() {
@@ -9302,9 +9463,9 @@ function untrackArchive(archive) {
   process.removeListener("exit", removePendingArchives);
 }
 function sha256File(filePath) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const hash = createHash2("sha256");
-    createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve8(hash.digest("hex"))).on("error", reject);
+    createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve9(hash.digest("hex"))).on("error", reject);
   });
 }
 function toolServerError(text) {
@@ -9331,7 +9492,7 @@ function uploadFailure(url, res, text, bytes) {
   });
 }
 async function uploadTar(tarPath, endpoint, signal) {
-  const { size } = await stat2(tarPath);
+  const { size } = await stat3(tarPath);
   const init = {
     method: "POST",
     headers: {
@@ -9355,7 +9516,7 @@ async function uploadTar(tarPath, endpoint, signal) {
   return json.uploadId;
 }
 async function uploadFile(sourcePath, endpoint, signal) {
-  const tarPath = path9.join(tmpdir(), `argent-upload-${randomUUID4()}.tar.gz`);
+  const tarPath = path10.join(tmpdir(), `argent-upload-${randomUUID4()}.tar.gz`);
   trackArchive(tarPath);
   try {
     await createTarGzFile(await realpath2(sourcePath), tarPath);
@@ -9370,7 +9531,7 @@ async function uploadFile(sourcePath, endpoint, signal) {
 async function readFileInputWire(filePath, opts) {
   let st;
   try {
-    st = await stat2(filePath);
+    st = await stat3(filePath);
   } catch {
     return null;
   }
@@ -9398,7 +9559,7 @@ async function prepareFileInputs(specs, args, opts) {
   for (const spec of specs) {
     if (spec.skipWhenSet && record[spec.skipWhenSet] !== void 0) continue;
     if (spec.target in record && typeof record[spec.target] !== "string") continue;
-    const filePath = interpolatePath(spec.path, record);
+    const filePath = await specPath(spec, record);
     if (filePath === null) continue;
     if (spec.target in record && record[spec.target] !== filePath) continue;
     const wire = { [FILE_INPUT_MARKER2]: true, path: filePath };
@@ -9416,13 +9577,13 @@ async function prepareFileInputs(specs, args, opts) {
       wire.members = await opts.collectStepMembers(record, opts);
     }
     if (spec.kind === "tar-upload") {
-      const st = await stat2(filePath).catch(() => null);
+      const st = await stat3(filePath).catch(() => null);
       if (st) {
         wire.size = st.size;
         wire.mtimeMs = st.mtimeMs;
       }
       if (opts.uploadEndpoint && st) {
-        process.stderr.write(`Uploading ${path9.basename(filePath)} to the remote tool-server...
+        process.stderr.write(`Uploading ${path10.basename(filePath)} to the remote tool-server...
 `);
         Object.assign(wire, await uploadFile(filePath, opts.uploadEndpoint, opts.signal));
       }
@@ -9433,18 +9594,18 @@ async function prepareFileInputs(specs, args, opts) {
   return out ?? args;
 }
 function isAllowedClientFilePath(p) {
-  if (!path9.isAbsolute(p)) return false;
+  if (!path10.isAbsolute(p)) return false;
   const segments = p.split(/[\\/]+/);
   if (segments.includes("..")) return false;
   const file = segments[segments.length - 1] ?? "";
   if (!FLOW_FILE_NAME_PATTERN.test(file)) return false;
-  return segments[segments.length - 3] === ".argent" && segments[segments.length - 2] === "flows";
+  return e2eDirProject(segments.slice(0, -1).join("/")) !== null;
 }
 function isClientFileDirective2(value) {
   return !!value && typeof value === "object" && value[CLIENT_FILE_MARKER2] === true && typeof value.path === "string" && typeof value.content === "string";
 }
 async function replaceFile(target, bytes, mode) {
-  const temp = path9.join(path9.dirname(target), `.baseline-${randomUUID4()}.tmp`);
+  const temp = path10.join(path10.dirname(target), `.baseline-${randomUUID4()}.tmp`);
   try {
     await writeFile3(temp, bytes, { flag: "wx" });
     if (mode !== void 0) await chmod3(temp, mode & 511);
@@ -9455,27 +9616,27 @@ async function replaceFile(target, bytes, mode) {
   }
 }
 async function writeBaselineFile(file, bytes, allowedDirs) {
-  if (!path9.isAbsolute(file) || path9.normalize(file) !== file || file.split(/[\\/]/).includes("..") || !file.endsWith(".png") || !allowedDirs.includes(path9.dirname(file))) {
+  if (!path10.isAbsolute(file) || path10.normalize(file) !== file || file.split(/[\\/]/).includes("..") || !file.endsWith(".png") || !allowedDirs.includes(path10.dirname(file))) {
     return allowedDirs.length === 0 ? "this call writes no baselines" : `${file} is not a baseline of this call (${allowedDirs.map((d) => `${d}/<name>.png`).join(", ")})`;
   }
   if (bytes.length > MAX_CONTENT_BYTES) {
     return `${file}: the baseline is larger than the 32 MiB cap on a file this client writes`;
   }
-  const dir = path9.dirname(file);
+  const dir = path10.dirname(file);
   await mkdir3(dir, { recursive: true });
   const link = await lstat(file).catch(() => null);
   const real = link === null ? null : await realpath2(file).catch(() => null);
   if (link !== null && real === null) return `${file} is a symbolic link to a missing file`;
   if (real !== null) {
     if (!real.endsWith(".png")) return `${file} links to a file that is not a PNG file`;
-    if (path9.dirname(real) !== await realpath2(dir)) {
+    if (path10.dirname(real) !== await realpath2(dir)) {
       return `${file} links outside its baseline directory`;
     }
   }
-  const existing = real === null ? null : await stat2(real);
+  const existing = real === null ? null : await stat3(real);
   if (existing !== null && !existing.isFile()) return `${file} is not a regular file`;
   await replaceFile(
-    real ?? path9.join(await realpath2(dir), path9.basename(file)),
+    real ?? path10.join(await realpath2(dir), path10.basename(file)),
     bytes,
     existing?.mode
   );
@@ -9501,7 +9662,7 @@ async function applyClientFileDirectives(result, opts = {}) {
     if (isClientFileDirective2(value)) {
       if (!isAllowedClientFilePath(value.path)) return null;
       try {
-        await mkdir3(path9.dirname(value.path), { recursive: true });
+        await mkdir3(path10.dirname(value.path), { recursive: true });
         await writeFile3(value.path, value.content, "utf8");
         written.push(value.path);
         return value.path;
@@ -9528,13 +9689,15 @@ async function applyClientFileDirectives(result, opts = {}) {
 }
 
 // ../argent-tools-client/src/flow-files.ts
-var import_yaml = __toESM(require_dist(), 1);
-import { readdir as readdir4, readFile as readFile4, realpath as realpath3, stat as stat3 } from "node:fs/promises";
-import * as path10 from "node:path";
+var import_yaml = __toESM(require_dist2(), 1);
+import { readdir as readdir4, readFile as readFile4, realpath as realpath3, stat as stat4 } from "node:fs/promises";
+import * as path11 from "node:path";
 var INLINE_MEMBERS_BYTES = 256 * 1024;
-var FLOW_FILES_LOG_ENV = "ARGENT_FLOW_FILES_LOG";
+function filesLogEnabled() {
+  return (process.env.ARGENT_E2E_FILES_LOG ?? process.env.ARGENT_FLOW_FILES_LOG) === "1";
+}
 function isWithin(inner, outer) {
-  return inner === outer || inner.startsWith(outer.endsWith(path10.sep) ? outer : outer + path10.sep);
+  return inner === outer || inner.startsWith(outer.endsWith(path11.sep) ? outer : outer + path11.sep);
 }
 function printable(text) {
   return [...text].map(
@@ -9542,23 +9705,21 @@ function printable(text) {
   ).join("");
 }
 function isResolvedAbsolute2(value) {
-  return typeof value === "string" && path10.isAbsolute(value) && !value.split(/[\\/]+/).includes("..");
+  return typeof value === "string" && path11.isAbsolute(value) && !value.split(/[\\/]+/).includes("..");
 }
 function namesValidFlow(args) {
   const { project_root, flow_path, name } = args;
   if (!isResolvedAbsolute2(project_root)) return false;
   if (name === void 0) {
-    return isResolvedAbsolute2(flow_path) && FLOW_FILE_NAME_PATTERN.test(path10.basename(flow_path));
+    return isResolvedAbsolute2(flow_path) && FLOW_FILE_NAME_PATTERN.test(path11.basename(flow_path));
   }
   return flow_path === void 0 && typeof name === "string" && FLOW_NAME_PATTERN.test(name);
 }
 function savedFlowProject(file) {
-  if (!path10.isAbsolute(file)) return null;
-  const parts = file.split(path10.sep);
-  for (let i = parts.length - 3; i >= 0; i--) {
-    if (parts[i] === ".argent" && parts[i + 1] === "flows") {
-      return parts.slice(0, i).join(path10.sep) || path10.sep;
-    }
+  if (!path11.isAbsolute(file)) return null;
+  for (let dir = path11.dirname(file); dir !== path11.dirname(dir); dir = path11.dirname(dir)) {
+    const project = e2eDirProject(dir);
+    if (project !== null) return project;
   }
   return null;
 }
@@ -9571,11 +9732,11 @@ async function landing(spelled) {
     const canonical = await canonicalFlowPath(spelled);
     let at = spelled;
     for (; ; ) {
-      const parent = path10.dirname(at);
+      const parent = path11.dirname(at);
       if (parent === at) return { canonical, fence: spelled, ...failure };
       const real = await realpath3(parent).catch(() => null);
       if (real !== null) {
-        return { canonical, fence: path10.join(real, path10.basename(at)), ...failure };
+        return { canonical, fence: path11.join(real, path11.basename(at)), ...failure };
       }
       at = parent;
     }
@@ -9583,10 +9744,10 @@ async function landing(spelled) {
 }
 async function closureRoots(rootPath, rootCanonical, projectRoot) {
   const candidates = [];
-  if (typeof projectRoot === "string" && path10.isAbsolute(projectRoot)) {
-    candidates.push(projectRoot, path10.join(projectRoot, ".argent", "flows"));
+  if (typeof projectRoot === "string" && path11.isAbsolute(projectRoot)) {
+    candidates.push(projectRoot, ...e2eDirsFor(projectRoot));
   }
-  candidates.push(path10.dirname(rootPath), path10.dirname(rootCanonical));
+  candidates.push(path11.dirname(rootPath), path11.dirname(rootCanonical));
   for (const file of [rootPath, rootCanonical]) {
     const project = savedFlowProject(file);
     if (project !== null) candidates.push(project);
@@ -9599,11 +9760,11 @@ async function closureRoots(rootPath, rootCanonical, projectRoot) {
   return real.filter((root) => !real.some((other) => other !== root && isWithin(root, other)));
 }
 async function readFlowMember(anchorDir, target, roots, budget, opts) {
-  const spelled = anchorDir + path10.sep + target;
+  const spelled = anchorDir + path11.sep + target;
   const { canonical, fence, missing, error } = await landing(spelled);
   const spelling = await classifyOnDiskSpelling(
-    path10.dirname(spelled),
-    path10.posix.basename(target),
+    path11.dirname(spelled),
+    path11.posix.basename(target),
     FLOW_FILE_NAME_PATTERN
   );
   const member = {
@@ -9622,13 +9783,13 @@ async function readFlowMember(anchorDir, target, roots, budget, opts) {
   }
   if (error !== void 0) return refuse(error);
   if (missing) return { member: { ...member, state: "missing" }, sent: "missing" };
-  const st = await stat3(canonical).catch((err) => err);
+  const st = await stat4(canonical).catch((err) => err);
   if (st instanceof Error) {
     if (st.code !== "ENOENT") return refuse(st.message);
     return { member: { ...member, state: "missing" }, sent: "missing" };
   }
   if (st.isDirectory()) return refuse("EISDIR: illegal operation on a directory, read");
-  if (!/\.ya?ml$/i.test(path10.basename(canonical))) {
+  if (!/\.ya?ml$/i.test(path11.basename(canonical))) {
     return refuse(`${target} links to a file that is not a YAML file`);
   }
   const sent = await sendBytes(member, canonical, budget, opts);
@@ -9647,7 +9808,7 @@ async function readToolMember(file, roots, budget, opts) {
   if (!hasToolFileExtension(canonical)) {
     return refuse(`${file} links to a file that is not one of ${TOOL_FILE_EXTENSIONS.join(", ")}`);
   }
-  const st = await stat3(canonical).catch((err) => err);
+  const st = await stat4(canonical).catch((err) => err);
   if (st instanceof Error) {
     if (st.code === "ENOENT" || st.code === "ENOTDIR") {
       return { member: { ...member, state: "missing" }, sent: "missing" };
@@ -9671,7 +9832,7 @@ async function baselineEntry(file, roots, forWrite) {
     };
   }
   if (error !== void 0) return { state: "refused", error };
-  const st = await stat3(canonical).catch((err) => err);
+  const st = await stat4(canonical).catch((err) => err);
   if (st instanceof Error) {
     if (st.code !== "ENOENT") return { state: "refused", error: st.message };
     return forWrite ? { state: "refused", error: `${file} is a symbolic link to a missing file` } : { state: "missing" };
@@ -9721,7 +9882,7 @@ function memberCollector(roots, opts) {
   const runs = /* @__PURE__ */ new Set();
   const baselineDirs = /* @__PURE__ */ new Map();
   const budget = { inline: 0 };
-  const logging = process.env[FLOW_FILES_LOG_ENV] === "1";
+  const logging = filesLogEnabled();
   const log = opts.log ?? ((line) => void process.stderr.write(`${line}
 `));
   const emit = (member, sent) => {
@@ -9729,18 +9890,19 @@ function memberCollector(roots, opts) {
     const subject = member.role === "flow" ? member.canonical : member.key;
     if (logging) log(printable(`[flow-files] ${member.role} ${subject}: ${sent}`));
   };
-  async function flow(anchorDir, target) {
+  async function flow(anchorDir, target, onlyPresent) {
     const key = flowMemberKey(anchorDir, target);
     const known = flows.get(key);
-    if (known !== void 0) return known;
+    if (known !== void 0) return onlyPresent && known.text === void 0 ? void 0 : known;
     const { member, text, sent } = await readFlowMember(anchorDir, target, roots, budget, opts);
+    if (onlyPresent && text === void 0) return void 0;
     const entry = { member, ...text === void 0 ? {} : { text } };
     flows.set(key, entry);
     emit(member, sent);
     return entry;
   }
   async function toolFiles(step) {
-    if (step.tool === "flow-execute") return;
+    if (canonicalToolId(step.tool) === "e2e-execute") return;
     for (const file of toolStepFiles(opts.toolFileInputs?.(step.tool), step.args)) {
       const { unwrapWhenSet } = file.spec;
       if (unwrapWhenSet !== void 0 && step.args[unwrapWhenSet] !== void 0) continue;
@@ -9750,11 +9912,31 @@ function memberCollector(roots, opts) {
       emit(read.member, read.sent);
     }
   }
+  async function savedTest(target) {
+    for (const candidate of target.paths) {
+      const found = await flow(path11.dirname(candidate), path11.basename(candidate), true);
+      if (found !== void 0) return found;
+    }
+    let first;
+    for (const candidate of target.paths) {
+      first ??= await flow(path11.dirname(candidate), path11.basename(candidate));
+    }
+    return first;
+  }
   async function nestedRun(target, hop, updates, platform) {
-    const { member, text } = await flow(path10.dirname(target.path), `${target.name}.yaml`);
+    const { member, text } = await savedTest(target);
     if (text === void 0 || hop >= MAX_RUN_DEPTH) return void 0;
     return { canonical: member.canonical, text, flowName: target.name, hop, updates, platform };
   }
+  async function runTarget(anchorDir, target) {
+    const found = await flow(anchorDir, target);
+    if (found.member.spelling?.state !== "absent") return found;
+    for (const dir of e2eRunFallbackDirs(anchorDir, target)) {
+      const other = await flow(dir, target, true);
+      if (other !== void 0) return other;
+    }
+    return found;
+  }
   async function walk(start) {
     const queue = [...start];
     for (let run = queue.shift(); run !== void 0; run = queue.shift()) {
@@ -9774,12 +9956,12 @@ function memberCollector(roots, opts) {
         const requests = collectFlowRequests(doc);
         for (const name of requests.snapshots) snapshots.add(name);
         for (const step of requests.toolSteps) await toolFiles(step);
-        const anchorDir = path10.dirname(file.canonical);
+        const anchorDir = path11.dirname(file.canonical);
         for (const target of requests.runTargets) {
           const key = flowMemberKey(anchorDir, target);
           if (visited.has(key)) continue;
           visited.add(key);
-          const { member, text } = await flow(anchorDir, target);
+          const { member, text } = await runTarget(anchorDir, target);
           if (text !== void 0 && file.hop + 1 < MAX_RUN_DEPTH) {
             files.push({ canonical: member.canonical, text, hop: file.hop + 1 });
           }
@@ -9796,8 +9978,8 @@ function memberCollector(roots, opts) {
         }
       }
       if (snapshots.size === 0) continue;
-      const dir = path10.join(
-        path10.dirname(run.canonical),
+      const dir = path11.join(
+        path11.dirname(run.canonical),
         "__baselines__",
         baselineKeyFor(run.canonical, run.flowName)
       );
@@ -9821,7 +10003,7 @@ function memberCollector(roots, opts) {
         if (!name.endsWith(".png")) continue;
         const compared = [...prefixes].some((prefix) => name.startsWith(prefix));
         if (!updates && !compared) continue;
-        const file = path10.join(dir, name);
+        const file = path11.join(dir, name);
         if (tools.has(file)) continue;
         const member = { role: "baseline", key: file, path: file };
         const entry = await baselineEntry(file, roots, updates && !compared);
@@ -9844,8 +10026,8 @@ async function collectFlowMembers(rootPath, rootBytes, args, opts) {
   if (!namesValidFlow(args)) return {};
   const canonical = await canonicalFlowPath(rootPath);
   const spelling = await classifyOnDiskSpelling(
-    path10.dirname(rootPath),
-    path10.basename(rootPath),
+    path11.dirname(rootPath),
+    path11.basename(rootPath),
     FLOW_FILE_NAME_PATTERN
   );
   const collector = memberCollector(
@@ -9856,7 +10038,7 @@ async function collectFlowMembers(rootPath, rootBytes, args, opts) {
     {
       canonical,
       text: rootBytes.toString("utf8"),
-      flowName: path10.basename(rootPath, ".yaml"),
+      flowName: path11.basename(rootPath, ".yaml"),
       hop: 0,
       updates: args.updateBaselines === true,
       platform: callPlatform(args)
@@ -9879,33 +10061,37 @@ function recordedStep(args) {
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
   return { tool: command, args: parsed };
 }
-async function collectStepMembers(args, opts) {
+async function collectStepMembers(args, opts, recordingDirFor = e2eDirFor) {
   const { name, project_root: projectRoot } = args;
   const step = recordedStep(args);
-  if (typeof name !== "string" || !FLOW_NAME_PATTERN.test(name) || typeof projectRoot !== "string" || !path10.isAbsolute(projectRoot) || step === void 0) {
+  if (typeof name !== "string" || !FLOW_NAME_PATTERN.test(name) || typeof projectRoot !== "string" || !path11.isAbsolute(projectRoot) || step === void 0) {
     return [];
   }
-  const recording = path10.join(projectRoot, ".argent", "flows", `${name}.yaml`);
+  const recording = path11.join(recordingDirFor(projectRoot), `${name}.yaml`);
   const collector = memberCollector(
     await closureRoots(recording, (await landing(recording)).canonical, projectRoot),
     opts
   );
   await collector.toolFiles(step);
-  if (step.tool === "flow-execute") {
-    const self = await collector.flow(path10.dirname(recording), path10.basename(recording));
+  if (canonicalToolId(step.tool) === "e2e-execute") {
+    const self = await collector.flow(path11.dirname(recording), path11.basename(recording));
     let runArgs = step.args;
     const named = nestedFlowTarget(runArgs);
     if (named?.kind === "flow_path") {
-      const stem = path10.basename(named.path, ".yaml");
-      if (path10.resolve(path10.dirname(named.path)) === path10.resolve(path10.dirname(recording))) {
-        await collector.flow(path10.dirname(recording), path10.basename(named.path));
+      const stem = path11.basename(named.path, ".yaml");
+      const base = path11.basename(named.path);
+      const dir = path11.resolve(path11.dirname(named.path));
+      const recordingDir = path11.dirname(recording);
+      const dirs = [recordingDir, ...e2eRunFallbackDirs(recordingDir, base)];
+      if (dirs.some((d) => path11.resolve(d) === dir)) {
+        await collector.flow(path11.dirname(named.path), base);
         runArgs = { ...runArgs, name: stem };
         delete runArgs.flow_path;
       }
     }
     const target = nestedFlowTarget(runArgs);
     if (target?.kind === "name") {
-      await collector.flow(path10.dirname(self.member.canonical), `${target.name}.yaml`);
+      await collector.flow(path11.dirname(self.member.canonical), `${target.name}.yaml`);
       const run = await collector.nestedRun(
         target,
         0,
@@ -9918,6 +10104,43 @@ async function collectStepMembers(args, opts) {
   await collector.sendBaselines();
   return collector.members;
 }
+async function nameToE2ePathForOlderServer(tool, fileInputs, args) {
+  const id = canonicalToolId(tool);
+  if (id !== "e2e-execute" && id !== "e2e-read-prerequisite") return args;
+  const spec = fileInputs?.find((s) => s.target === "flow_file");
+  if (spec === void 0 || spec.kind !== "file" || spec.paths?.length) return args;
+  const target = nestedFlowTarget(args);
+  if (target?.kind !== "name") return args;
+  const picked = await pickE2eFile(target.paths);
+  if (!picked.exists || picked.legacy) return args;
+  const { name: _name, ...rest } = args;
+  return { ...rest, flow_path: picked.path };
+}
+async function stepForOlderServer(args, listedId) {
+  if (typeof args !== "object" || args === null || Array.isArray(args)) return args;
+  const record = args;
+  if (typeof record.command !== "string") return args;
+  const command = listedId(record.command) ?? record.command;
+  const step = recordedStep({ ...record, command });
+  const target = step && canonicalToolId(step.tool) === "e2e-execute" && nestedFlowTarget(step.args);
+  if (target && target.kind === "name") {
+    const picked = await pickE2eFile(target.paths);
+    if (picked.exists && !picked.legacy) {
+      throw new Error(
+        `Cannot record a nested ${record.command} of "${target.name}": the tool-server runs an older argent that records and runs nested e2e tests only from .argent/flows/, and "${target.name}" is ${picked.path}. Upgrade the tool-server to record it, or run it with e2e-execute outside the recording.`
+      );
+    }
+  }
+  return command === record.command ? args : { ...record, command };
+}
+async function e2eShadowWarningFor(tool, args) {
+  const id = canonicalToolId(tool);
+  if (id !== "e2e-execute" && id !== "e2e-read-prerequisite") return void 0;
+  const target = nestedFlowTarget(args);
+  if (target?.kind !== "name") return void 0;
+  const picked = await pickE2eFile(target.paths);
+  return picked.shadowed === void 0 ? void 0 : e2eShadowWarning(picked.path, picked.shadowed);
+}
 
 // ../argent-tools-client/src/tools-client.ts
 function authHeaders2(token) {
@@ -9995,6 +10218,10 @@ function errorBodyMessage(body) {
   if (Array.isArray(body.issues) && typeof body.message === "string") return body.message;
   return body.error ?? body.message;
 }
+function findTool(tools, name) {
+  const id = canonicalToolId(name);
+  return tools.find((t) => t.name === name) ?? tools.find((t) => canonicalToolId(t.name) === id) ?? null;
+}
 function assertRequiredPresent(meta, args) {
   const record = typeof args === "object" && args !== null ? args : {};
   const schema = meta.inputSchema;
@@ -10070,26 +10297,33 @@ function createToolsClient(options = {}) {
     return json.tools;
   }
   async function fetchTool(name, opts) {
-    const tools = await fetchTools(opts);
-    return tools.find((t) => t.name === name) ?? null;
+    return findTool(await fetchTools(opts), name);
   }
   async function callTool(name, args, opts) {
     opts?.signal?.throwIfAborted();
     const { url, token, remote } = await route();
     let finalArgs = args;
     const tools = await fetchTools({ signal: opts?.signal });
-    const meta = tools.find((t) => t.name === name) ?? null;
+    const meta = findTool(tools, name);
+    const olderServer = meta !== null && !tools.some((t) => t.name === canonicalToolId(meta.name));
+    if (meta) {
+      finalArgs = await nameToE2ePathForOlderServer(meta.name, meta.fileInputs, args);
+    }
+    if (olderServer && canonicalToolId(meta.name) === "e2e-add-step") {
+      finalArgs = await stepForOlderServer(finalArgs, (tool) => findTool(tools, tool)?.name);
+    }
+    const shadowWarning = await e2eShadowWarningFor(name, args);
     const baselineDirs = [];
     if (meta?.fileInputs?.length) {
-      if (remote) assertRequiredPresent(meta, args);
-      finalArgs = await prepareFileInputs(meta.fileInputs, args ?? {}, {
+      if (remote) assertRequiredPresent(meta, finalArgs);
+      finalArgs = await prepareFileInputs(meta.fileInputs, finalArgs ?? {}, {
         includeContent: remote,
         uploadEndpoint: remote ? { url, token } : void 0,
         log: diagnose,
         baselineDirs,
         collectMembers: collectFlowMembers,
-        collectStepMembers,
-        toolFileInputs: (tool) => tools.find((t) => t.name === tool)?.fileInputs,
+        collectStepMembers: olderServer ? (record, o) => collectStepMembers(record, o, (root) => path12.join(root, LEGACY_E2E_DIRS[0])) : collectStepMembers,
+        toolFileInputs: (tool) => findTool(tools, tool)?.fileInputs,
         signal: opts?.signal
       });
     }
@@ -10098,19 +10332,23 @@ function createToolsClient(options = {}) {
       for (const { path: file, error } of applied.failed) {
         diagnose(`The baseline ${file} was not written on this client: ${error}`);
       }
-      if (process.env.ARGENT_FLOW_FILES_LOG === "1") {
+      if (filesLogEnabled()) {
         for (const file of applied.written) {
-          if (baselineDirs.includes(path11.dirname(file))) {
+          if (baselineDirs.includes(path12.dirname(file))) {
             diagnose(`[flow-files] baseline ${file}: written`);
           }
         }
       }
-      return applied.result;
+      const result = applied.result;
+      if (shadowWarning === void 0 || typeof result !== "object" || result === null || Array.isArray(result) || typeof result.warning === "string") {
+        return result;
+      }
+      return { ...result, warning: shadowWarning };
     };
     const stream = opts?.onProgress !== void 0 || carriesMembers(finalArgs);
     const sentOnce = carriesUpload(finalArgs);
     const res = await doFetch(
-      `${url}/tools/${encodeURIComponent(name)}`,
+      `${url}/tools/${encodeURIComponent(meta?.name ?? name)}`,
       {
         method: "POST",
         headers: {
@@ -10118,6 +10356,9 @@ function createToolsClient(options = {}) {
           // Tells the tool-server the call came over a link, a link to
           // 127.0.0.1 included, which nothing else in the request shows.
           ...remote ? { [LINKED_CALL_HEADER]: "1" } : {},
+          // Tells the tool-server this client writes recordings under
+          // `.argent/e2e/`; an older client writes only `.argent/flows/`.
+          [E2E_DIR_CLIENT_HEADER]: "1",
           // A proxy that compresses the stream holds each line until its buffer
           // fills. `identity` keeps the stream uncompressed end to end.
           ...stream ? { "Accept": "application/x-ndjson", "Accept-Encoding": "identity" } : {},
@@ -10175,10 +10416,10 @@ function createToolsClient(options = {}) {
 }
 
 // ../argent-tools-client/src/artifacts.ts
-import { copyFile, mkdir as mkdir4, readFile as readFile5, realpath as realpath4, rm as rm3, stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
+import { copyFile, mkdir as mkdir4, readFile as readFile5, realpath as realpath4, rm as rm3, stat as stat5, writeFile as writeFile4 } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename6, dirname as dirname8, extname as extname2, isAbsolute as isAbsolute6, join as join11, normalize as normalize2, resolve as resolve7, sep as sep4 } from "node:path";
+import { basename as basename7, dirname as dirname9, extname as extname2, isAbsolute as isAbsolute6, join as join13, normalize as normalize2, resolve as resolve8, sep as sep4 } from "node:path";
 import { createHash as createHash3 } from "node:crypto";
 var ARTIFACT_MARKER2 = "__argentArtifact";
 function isArtifactHandle(value) {
@@ -10198,20 +10439,20 @@ function sanitizeSegment(segment) {
 function projectSlug() {
   const cwd = process.cwd();
   const hash = createHash3("sha1").update(cwd).digest("hex").slice(0, 6);
-  const name = sanitizeSegment(basename6(cwd)) || "root";
+  const name = sanitizeSegment(basename7(cwd)) || "root";
   return `${name}-${hash}`;
 }
 function artifactsRoot() {
-  return process.env.ARGENT_ARTIFACTS_DIR ?? join11(tmpdir2(), "argent-artifacts");
+  return process.env.ARGENT_ARTIFACTS_DIR ?? join13(tmpdir2(), "argent-artifacts");
 }
 function artifactDir(deviceId) {
   const parts = [artifactsRoot(), projectSlug(), sessionId()];
   if (deviceId) parts.push(sanitizeSegment(deviceId));
-  return join11(...parts);
+  return join13(...parts);
 }
 function durableBaseDir() {
   const projectRoot = findProjectRoot(process.cwd());
-  return projectRoot ?? dirname8(argentHomeDir());
+  return projectRoot ?? dirname9(argentHomeDir());
 }
 var ALLOWED_SAVE_DIRS = /* @__PURE__ */ new Set([normalize2(".argent/recordings")]);
 var RECORDINGS_SAVE_DIR = normalize2(".argent/recordings");
@@ -10225,9 +10466,9 @@ function configuredRecordingsDir() {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
   if (trimmed === "") return null;
-  const home = dirname8(argentHomeDir());
-  const expanded = trimmed === "~" ? home : trimmed.startsWith("~/") || trimmed.startsWith(`~${sep4}`) ? join11(home, trimmed.slice(2)) : trimmed;
-  return resolve7(durableBaseDir(), expanded);
+  const home = dirname9(argentHomeDir());
+  const expanded = trimmed === "~" ? home : trimmed.startsWith("~/") || trimmed.startsWith(`~${sep4}`) ? join13(home, trimmed.slice(2)) : trimmed;
+  return resolve8(durableBaseDir(), expanded);
 }
 var MAX_DURABLE_BYTES = 2 * 1024 * 1024 * 1024;
 async function readCapped(res, cap) {
@@ -10260,10 +10501,10 @@ async function writeDurableUnique(dir, filename, write) {
   const stem = filename.slice(0, filename.length - ext.length);
   for (let i = 1; i <= 1e3; i++) {
     const candidate = i === 1 ? filename : `${stem} (${i})${ext}`;
-    const path13 = join11(dir, candidate);
+    const path14 = join13(dir, candidate);
     try {
-      await write(path13);
-      return path13;
+      await write(path14);
+      return path14;
     } catch (err) {
       if (err?.code === "EEXIST") continue;
       throw err;
@@ -10283,21 +10524,21 @@ function durableSaveTarget(handle) {
     if (configured) {
       return {
         dir: configured,
-        path: join11(configured, sanitizeSegment(handle.filename)),
+        path: join13(configured, sanitizeSegment(handle.filename)),
         base: configured,
         rel: ""
       };
     }
   }
   const base = durableBaseDir();
-  const dir = join11(base, rel);
-  return { dir, path: join11(dir, sanitizeSegment(handle.filename)), base, rel };
+  const dir = join13(base, rel);
+  return { dir, path: join13(dir, sanitizeSegment(handle.filename)), base, rel };
 }
 async function confineToRealBase(dir, base, rel) {
   try {
     const realDir = await realpath4(dir);
     const realBase = await realpath4(base);
-    return realDir === join11(realBase, rel);
+    return realDir === join13(realBase, rel);
   } catch {
     return false;
   }
@@ -10305,7 +10546,7 @@ async function confineToRealBase(dir, base, rel) {
 async function resolveLocalFile(handle) {
   if (!handle.hostPath) return null;
   try {
-    const st = await stat4(handle.hostPath);
+    const st = await stat5(handle.hostPath);
     if (handle.archive) {
       return st.isDirectory() ? handle.hostPath : null;
     }
@@ -10320,7 +10561,7 @@ async function resolveLocalFile(handle) {
   }
 }
 async function downloadAndExtractArchive(handle, data, dir) {
-  const tarball = join11(dir, `${sanitizeSegment(handle.filename)}.tar.gz`);
+  const tarball = join13(dir, `${sanitizeSegment(handle.filename)}.tar.gz`);
   try {
     await writeFile4(tarball, data);
     return await safeExtractTarGz(tarball, dir, handle.filename);
@@ -10348,7 +10589,7 @@ async function materializeArtifacts(result, ctx) {
       const localPath = await resolveLocalFile(value);
       const saveTarget = durableSaveTarget(value);
       if (saveTarget) {
-        const filename = basename6(saveTarget.path);
+        const filename = basename7(saveTarget.path);
         try {
           await mkdir4(saveTarget.dir, { recursive: true });
           if (!await confineToRealBase(saveTarget.dir, saveTarget.base, saveTarget.rel)) {
@@ -10412,7 +10653,7 @@ async function materializeArtifacts(result, ctx) {
           return await downloadAndExtractArchive(value, data, dir);
         }
         if (value.size > 0 && data.length !== value.size) return null;
-        const downloadedPath = join11(dir, sanitizeSegment(value.filename));
+        const downloadedPath = join13(dir, sanitizeSegment(value.filename));
         await writeFile4(downloadedPath, data);
         if (value.mimeType.startsWith("image/")) {
           images.push({ localPath: downloadedPath, data, mimeType: value.mimeType });
@@ -10446,12 +10687,12 @@ function getDeviceIdFromArgs(args) {
 }
 
 // src/bundled-paths.ts
-import * as fs6 from "node:fs";
-import * as path12 from "node:path";
+import * as fs7 from "node:fs";
+import * as path13 from "node:path";
 function readPackageVersion() {
   try {
     const pkg = JSON.parse(
-      fs6.readFileSync(path12.join(import.meta.dirname, "..", "package.json"), "utf8")
+      fs7.readFileSync(path13.join(import.meta.dirname, "..", "package.json"), "utf8")
     );
     return pkg.version;
   } catch {
@@ -10462,15 +10703,15 @@ var PACKAGE_NAME = "@swmansion/argent";
 function findDeclaringRoot(startDir) {
   let dir = startDir;
   for (; ; ) {
-    if (fs6.existsSync(path12.join(dir, ".argent", "install.json"))) return dir;
+    if (fs7.existsSync(path13.join(dir, ".argent", "install.json"))) return dir;
     try {
-      const manifest = JSON.parse(fs6.readFileSync(path12.join(dir, "package.json"), "utf8"));
+      const manifest = JSON.parse(fs7.readFileSync(path13.join(dir, "package.json"), "utf8"));
       if (manifest.devDependencies?.[PACKAGE_NAME] || manifest.dependencies?.[PACKAGE_NAME] || manifest.optionalDependencies?.[PACKAGE_NAME]) {
         return dir;
       }
     } catch {
     }
-    const parent = path12.dirname(dir);
+    const parent = path13.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -10478,12 +10719,12 @@ function findDeclaringRoot(startDir) {
 function findStablePackageDir(startDir, packageRoot) {
   let dir = startDir;
   for (; ; ) {
-    const candidate = path12.join(dir, "node_modules", PACKAGE_NAME);
+    const candidate = path13.join(dir, "node_modules", PACKAGE_NAME);
     try {
-      if (fs6.realpathSync(candidate) === packageRoot) return candidate;
+      if (fs7.realpathSync(candidate) === packageRoot) return candidate;
     } catch {
     }
-    const parent = path12.dirname(dir);
+    const parent = path13.dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -10493,7 +10734,7 @@ function classifyInstall() {
   let dir;
   let cwd;
   try {
-    packageRoot = fs6.realpathSync(path12.join(import.meta.dirname, ".."));
+    packageRoot = fs7.realpathSync(path13.join(import.meta.dirname, ".."));
     cwd = process.cwd();
     dir = cwd;
   } catch {
@@ -10501,8 +10742,8 @@ function classifyInstall() {
   }
   for (; ; ) {
     try {
-      const nmReal = fs6.realpathSync(path12.join(dir, "node_modules"));
-      if (packageRoot === nmReal || packageRoot.startsWith(nmReal + path12.sep)) {
+      const nmReal = fs7.realpathSync(path13.join(dir, "node_modules"));
+      if (packageRoot === nmReal || packageRoot.startsWith(nmReal + path13.sep)) {
         return {
           kind: "local",
           projectRoot: findDeclaringRoot(cwd) ?? dir,
@@ -10511,22 +10752,22 @@ function classifyInstall() {
       }
     } catch {
     }
-    const parent = path12.dirname(dir);
+    const parent = path13.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  if (packageRoot.includes(`${path12.sep}.yarn${path12.sep}`)) {
+  if (packageRoot.includes(`${path13.sep}.yarn${path13.sep}`)) {
     const declRoot = findDeclaringRoot(cwd);
     if (declRoot) return { kind: "local", projectRoot: declRoot };
   }
   return { kind: "global" };
 }
 var classifiedInstall = classifyInstall();
-var packageDir = classifiedInstall.stablePackageDir ?? path12.join(import.meta.dirname, "..");
+var packageDir = classifiedInstall.stablePackageDir ?? path13.join(import.meta.dirname, "..");
 var BUNDLED_RUNTIME_PATHS = {
-  bundlePath: path12.join(packageDir, "dist", "tool-server.cjs"),
-  simulatorServerDir: path12.join(packageDir, "bin"),
-  nativeDevtoolsDir: path12.join(packageDir, "dylibs"),
+  bundlePath: path13.join(packageDir, "dist", "tool-server.cjs"),
+  simulatorServerDir: path13.join(packageDir, "bin"),
+  nativeDevtoolsDir: path13.join(packageDir, "dylibs"),
   version: readPackageVersion(),
   installKind: classifiedInstall.kind,
   installProjectRoot: classifiedInstall.projectRoot
@@ -10564,7 +10805,7 @@ function createArgentClient() {
   }
   async function listTools(options) {
     const tools = await client.fetchTools({ signal: options?.signal });
-    return tools.map(({ name, description, inputSchema }) => ({ name, description, inputSchema }));
+    return tools.filter((tool) => tool.aliasOf === void 0).map(({ name, description, inputSchema }) => ({ name, description, inputSchema }));
   }
   async function callTool(name, args = {}, options) {
     try {