@qawolf/cli 1.7.4 → 1.7.5

package/dist/cli.js

@@ -3285,7 +3285,7 @@ var require_atomic_sleep = __commonJS((exports, module) => {
 
 // node_modules/sonic-boom/index.js
 var require_sonic_boom = __commonJS((exports, module) => {
-  var fs2 = __require("fs");
+  var fs3 = __require("fs");
   var EventEmitter = __require("events");
   var inherits = __require("util").inherits;
   var path2 = __require("path");
@@ -3343,21 +3343,21 @@ var require_sonic_boom = __commonJS((exports, module) => {
     if (sonic.sync) {
       try {
         if (sonic.mkdir)
-          fs2.mkdirSync(path2.dirname(file2), { recursive: true });
-        const fd = fs2.openSync(file2, flags, mode);
+          fs3.mkdirSync(path2.dirname(file2), { recursive: true });
+        const fd = fs3.openSync(file2, flags, mode);
         fileOpened(null, fd);
       } catch (err) {
         fileOpened(err);
         throw err;
       }
     } else if (sonic.mkdir) {
-      fs2.mkdir(path2.dirname(file2), { recursive: true }, (err) => {
+      fs3.mkdir(path2.dirname(file2), { recursive: true }, (err) => {
         if (err)
           return fileOpened(err);
-        fs2.open(file2, flags, mode, fileOpened);
+        fs3.open(file2, flags, mode, fileOpened);
       });
     } else {
-      fs2.open(file2, flags, mode, fileOpened);
+      fs3.open(file2, flags, mode, fileOpened);
     }
   }
   function SonicBoom(opts) {
@@ -3398,8 +3398,8 @@ var require_sonic_boom = __commonJS((exports, module) => {
       this.flush = flushBuffer;
       this.flushSync = flushBufferSync;
       this._actualWrite = actualWriteBuffer;
-      fsWriteSync = () => fs2.writeSync(this.fd, this._writingBuf);
-      fsWrite = () => fs2.write(this.fd, this._writingBuf, this.release);
+      fsWriteSync = () => fs3.writeSync(this.fd, this._writingBuf);
+      fsWrite = () => fs3.write(this.fd, this._writingBuf, this.release);
     } else if (contentMode === undefined || contentMode === kContentModeUtf8) {
       this._writingBuf = "";
       this.write = write;
@@ -3408,15 +3408,15 @@ var require_sonic_boom = __commonJS((exports, module) => {
       this._actualWrite = actualWrite;
       fsWriteSync = () => {
         if (Buffer.isBuffer(this._writingBuf)) {
-          return fs2.writeSync(this.fd, this._writingBuf);
+          return fs3.writeSync(this.fd, this._writingBuf);
         }
-        return fs2.writeSync(this.fd, this._writingBuf, "utf8");
+        return fs3.writeSync(this.fd, this._writingBuf, "utf8");
       };
       fsWrite = () => {
         if (Buffer.isBuffer(this._writingBuf)) {
-          return fs2.write(this.fd, this._writingBuf, this.release);
+          return fs3.write(this.fd, this._writingBuf, this.release);
         }
-        return fs2.write(this.fd, this._writingBuf, "utf8", this.release);
+        return fs3.write(this.fd, this._writingBuf, "utf8", this.release);
       };
     } else {
       throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
@@ -3473,7 +3473,7 @@ var require_sonic_boom = __commonJS((exports, module) => {
         }
       }
       if (this._fsync) {
-        fs2.fsyncSync(this.fd);
+        fs3.fsyncSync(this.fd);
       }
       const len = this._len;
       if (this._reopening) {
@@ -3588,7 +3588,7 @@ var require_sonic_boom = __commonJS((exports, module) => {
     const onDrain = () => {
       if (!this._fsync) {
         try {
-          fs2.fsync(this.fd, (err) => {
+          fs3.fsync(this.fd, (err) => {
             this._flushPending = false;
             cb(err);
           });
@@ -3690,7 +3690,7 @@ var require_sonic_boom = __commonJS((exports, module) => {
     const fd = this.fd;
     this.once("ready", () => {
       if (fd !== this.fd) {
-        fs2.close(fd, (err) => {
+        fs3.close(fd, (err) => {
           if (err) {
             return this.emit("error", err);
           }
@@ -3739,7 +3739,7 @@ var require_sonic_boom = __commonJS((exports, module) => {
         buf = this._bufs[0];
       }
       try {
-        const n = Buffer.isBuffer(buf) ? fs2.writeSync(this.fd, buf) : fs2.writeSync(this.fd, buf, "utf8");
+        const n = Buffer.isBuffer(buf) ? fs3.writeSync(this.fd, buf) : fs3.writeSync(this.fd, buf, "utf8");
         const releasedBufObj = releaseWritingBuf(buf, this._len, n);
         buf = releasedBufObj.writingBuf;
         this._len = releasedBufObj.len;
@@ -3755,7 +3755,7 @@ var require_sonic_boom = __commonJS((exports, module) => {
       }
     }
     try {
-      fs2.fsyncSync(this.fd);
+      fs3.fsyncSync(this.fd);
     } catch {}
   }
   function flushBufferSync() {
@@ -3775,7 +3775,7 @@ var require_sonic_boom = __commonJS((exports, module) => {
         buf = mergeBuf(this._bufs[0], this._lens[0]);
       }
       try {
-        const n = fs2.writeSync(this.fd, buf);
+        const n = fs3.writeSync(this.fd, buf);
         buf = buf.subarray(n);
         this._len = Math.max(this._len - n, 0);
         if (buf.length <= 0) {
@@ -3803,13 +3803,13 @@ var require_sonic_boom = __commonJS((exports, module) => {
     this._writingBuf = this._writingBuf.length ? this._writingBuf : this._bufs.shift() || "";
     if (this.sync) {
       try {
-        const written = Buffer.isBuffer(this._writingBuf) ? fs2.writeSync(this.fd, this._writingBuf) : fs2.writeSync(this.fd, this._writingBuf, "utf8");
+        const written = Buffer.isBuffer(this._writingBuf) ? fs3.writeSync(this.fd, this._writingBuf) : fs3.writeSync(this.fd, this._writingBuf, "utf8");
         release(null, written);
       } catch (err) {
         release(err);
       }
     } else {
-      fs2.write(this.fd, this._writingBuf, release);
+      fs3.write(this.fd, this._writingBuf, release);
     }
   }
   function actualWriteBuffer() {
@@ -3818,7 +3818,7 @@ var require_sonic_boom = __commonJS((exports, module) => {
     this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift());
     if (this.sync) {
       try {
-        const written = fs2.writeSync(this.fd, this._writingBuf);
+        const written = fs3.writeSync(this.fd, this._writingBuf);
         release(null, written);
       } catch (err) {
         release(err);
@@ -3827,7 +3827,7 @@ var require_sonic_boom = __commonJS((exports, module) => {
       if (kCopyBuffer) {
         this._writingBuf = Buffer.from(this._writingBuf);
       }
-      fs2.write(this.fd, this._writingBuf, release);
+      fs3.write(this.fd, this._writingBuf, release);
     }
   }
   function actualClose(sonic) {
@@ -3843,11 +3843,11 @@ var require_sonic_boom = __commonJS((exports, module) => {
     sonic._lens = [];
     assert2(typeof sonic.fd === "number", `sonic.fd must be a number, got ${typeof sonic.fd}`);
     try {
-      fs2.fsync(sonic.fd, closeWrapped);
+      fs3.fsync(sonic.fd, closeWrapped);
     } catch {}
     function closeWrapped() {
       if (sonic.fd !== 1 && sonic.fd !== 2) {
-        fs2.close(sonic.fd, done);
+        fs3.close(sonic.fd, done);
       } else {
         done();
       }
@@ -17258,14 +17258,14 @@ var require_load = __commonJS((exports, module) => {
       zipEntries.load(data2);
       return zipEntries;
     }).then(function checkCRC32(zipEntries) {
-      var promises2 = [external2.Promise.resolve(zipEntries)];
+      var promises3 = [external2.Promise.resolve(zipEntries)];
       var files = zipEntries.files;
       if (options.checkCRC32) {
         for (var i2 = 0;i2 < files.length; i2++) {
-          promises2.push(checkEntryCRC32(files[i2]));
+          promises3.push(checkEntryCRC32(files[i2]));
         }
       }
-      return external2.Promise.all(promises2);
+      return external2.Promise.all(promises3);
     }).then(function addFiles(results) {
       var zipEntries = results.shift();
       var files = zipEntries.files;
@@ -18963,7 +18963,7 @@ var init_strip_ansi = __esm(() => {
 });
 
 // node_modules/@wdio/logger/build/index.js
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import util from "node:util";
 function getLogger(name) {
   if (loggers[name]) {
@@ -19042,7 +19042,7 @@ var import_safe_regex2, import_loglevel, import_loglevel_plugin_prefix, SENSITIV
   const rawMethod = originalFactory(methodName, logLevel, loggerName);
   return (...args) => {
     if (!logFile && process.env.WDIO_LOG_PATH) {
-      logFile = fs3.createWriteStream(process.env.WDIO_LOG_PATH);
+      logFile = fs4.createWriteStream(process.env.WDIO_LOG_PATH);
     }
     const match = Object.values(matches).filter((x) => args[0].endsWith(`: ${x}`))[0];
     if (match) {
@@ -20043,13 +20043,13 @@ var require_minimatch = __commonJS((exports, module) => {
 // node_modules/readdir-glob/index.js
 var require_readdir_glob = __commonJS((exports, module) => {
   module.exports = readdirGlob;
-  var fs4 = __require("fs");
+  var fs5 = __require("fs");
   var { EventEmitter } = __require("events");
   var { Minimatch } = require_minimatch();
   var { resolve: resolve10 } = __require("path");
   function readdir3(dir, strict) {
     return new Promise((resolve11, reject) => {
-      fs4.readdir(dir, { withFileTypes: true }, (err, files) => {
+      fs5.readdir(dir, { withFileTypes: true }, (err, files) => {
         if (err) {
           switch (err.code) {
             case "ENOTDIR":
@@ -20078,7 +20078,7 @@ var require_readdir_glob = __commonJS((exports, module) => {
   }
   function stat2(file2, followSymlinks) {
     return new Promise((resolve11, reject) => {
-      const statFunc = followSymlinks ? fs4.stat : fs4.lstat;
+      const statFunc = followSymlinks ? fs5.stat : fs5.lstat;
       statFunc(file2, (err, stats) => {
         if (err) {
           switch (err.code) {
@@ -22202,54 +22202,54 @@ var require_polyfills = __commonJS((exports, module) => {
   }
   var chdir;
   module.exports = patch;
-  function patch(fs4) {
+  function patch(fs5) {
     if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-      patchLchmod(fs4);
-    }
-    if (!fs4.lutimes) {
-      patchLutimes(fs4);
-    }
-    fs4.chown = chownFix(fs4.chown);
-    fs4.fchown = chownFix(fs4.fchown);
-    fs4.lchown = chownFix(fs4.lchown);
-    fs4.chmod = chmodFix(fs4.chmod);
-    fs4.fchmod = chmodFix(fs4.fchmod);
-    fs4.lchmod = chmodFix(fs4.lchmod);
-    fs4.chownSync = chownFixSync(fs4.chownSync);
-    fs4.fchownSync = chownFixSync(fs4.fchownSync);
-    fs4.lchownSync = chownFixSync(fs4.lchownSync);
-    fs4.chmodSync = chmodFixSync(fs4.chmodSync);
-    fs4.fchmodSync = chmodFixSync(fs4.fchmodSync);
-    fs4.lchmodSync = chmodFixSync(fs4.lchmodSync);
-    fs4.stat = statFix(fs4.stat);
-    fs4.fstat = statFix(fs4.fstat);
-    fs4.lstat = statFix(fs4.lstat);
-    fs4.statSync = statFixSync(fs4.statSync);
-    fs4.fstatSync = statFixSync(fs4.fstatSync);
-    fs4.lstatSync = statFixSync(fs4.lstatSync);
-    if (fs4.chmod && !fs4.lchmod) {
-      fs4.lchmod = function(path3, mode, cb) {
+      patchLchmod(fs5);
+    }
+    if (!fs5.lutimes) {
+      patchLutimes(fs5);
+    }
+    fs5.chown = chownFix(fs5.chown);
+    fs5.fchown = chownFix(fs5.fchown);
+    fs5.lchown = chownFix(fs5.lchown);
+    fs5.chmod = chmodFix(fs5.chmod);
+    fs5.fchmod = chmodFix(fs5.fchmod);
+    fs5.lchmod = chmodFix(fs5.lchmod);
+    fs5.chownSync = chownFixSync(fs5.chownSync);
+    fs5.fchownSync = chownFixSync(fs5.fchownSync);
+    fs5.lchownSync = chownFixSync(fs5.lchownSync);
+    fs5.chmodSync = chmodFixSync(fs5.chmodSync);
+    fs5.fchmodSync = chmodFixSync(fs5.fchmodSync);
+    fs5.lchmodSync = chmodFixSync(fs5.lchmodSync);
+    fs5.stat = statFix(fs5.stat);
+    fs5.fstat = statFix(fs5.fstat);
+    fs5.lstat = statFix(fs5.lstat);
+    fs5.statSync = statFixSync(fs5.statSync);
+    fs5.fstatSync = statFixSync(fs5.fstatSync);
+    fs5.lstatSync = statFixSync(fs5.lstatSync);
+    if (fs5.chmod && !fs5.lchmod) {
+      fs5.lchmod = function(path3, mode, cb) {
         if (cb)
           process.nextTick(cb);
       };
-      fs4.lchmodSync = function() {};
+      fs5.lchmodSync = function() {};
     }
-    if (fs4.chown && !fs4.lchown) {
-      fs4.lchown = function(path3, uid, gid, cb) {
+    if (fs5.chown && !fs5.lchown) {
+      fs5.lchown = function(path3, uid, gid, cb) {
         if (cb)
           process.nextTick(cb);
       };
-      fs4.lchownSync = function() {};
+      fs5.lchownSync = function() {};
     }
     if (platform === "win32") {
-      fs4.rename = typeof fs4.rename !== "function" ? fs4.rename : function(fs$rename) {
+      fs5.rename = typeof fs5.rename !== "function" ? fs5.rename : function(fs$rename) {
         function rename(from, to2, cb) {
           var start = Date.now();
           var backoff = 0;
           fs$rename(from, to2, function CB(er2) {
             if (er2 && (er2.code === "EACCES" || er2.code === "EPERM" || er2.code === "EBUSY") && Date.now() - start < 60000) {
               setTimeout(function() {
-                fs4.stat(to2, function(stater, st2) {
+                fs5.stat(to2, function(stater, st2) {
                   if (stater && stater.code === "ENOENT")
                     fs$rename(from, to2, CB);
                   else
@@ -22267,9 +22267,9 @@ var require_polyfills = __commonJS((exports, module) => {
         if (Object.setPrototypeOf)
           Object.setPrototypeOf(rename, fs$rename);
         return rename;
-      }(fs4.rename);
+      }(fs5.rename);
     }
-    fs4.read = typeof fs4.read !== "function" ? fs4.read : function(fs$read) {
+    fs5.read = typeof fs5.read !== "function" ? fs5.read : function(fs$read) {
       function read(fd, buffer, offset, length, position, callback_) {
         var callback2;
         if (callback_ && typeof callback_ === "function") {
@@ -22277,23 +22277,23 @@ var require_polyfills = __commonJS((exports, module) => {
           callback2 = function(er2, _4, __) {
             if (er2 && er2.code === "EAGAIN" && eagCounter < 10) {
               eagCounter++;
-              return fs$read.call(fs4, fd, buffer, offset, length, position, callback2);
+              return fs$read.call(fs5, fd, buffer, offset, length, position, callback2);
             }
             callback_.apply(this, arguments);
           };
         }
-        return fs$read.call(fs4, fd, buffer, offset, length, position, callback2);
+        return fs$read.call(fs5, fd, buffer, offset, length, position, callback2);
       }
       if (Object.setPrototypeOf)
         Object.setPrototypeOf(read, fs$read);
       return read;
-    }(fs4.read);
-    fs4.readSync = typeof fs4.readSync !== "function" ? fs4.readSync : function(fs$readSync) {
+    }(fs5.read);
+    fs5.readSync = typeof fs5.readSync !== "function" ? fs5.readSync : function(fs$readSync) {
       return function(fd, buffer, offset, length, position) {
         var eagCounter = 0;
         while (true) {
           try {
-            return fs$readSync.call(fs4, fd, buffer, offset, length, position);
+            return fs$readSync.call(fs5, fd, buffer, offset, length, position);
           } catch (er2) {
             if (er2.code === "EAGAIN" && eagCounter < 10) {
               eagCounter++;
@@ -22303,90 +22303,90 @@ var require_polyfills = __commonJS((exports, module) => {
           }
         }
       };
-    }(fs4.readSync);
-    function patchLchmod(fs5) {
-      fs5.lchmod = function(path3, mode, callback2) {
-        fs5.open(path3, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
+    }(fs5.readSync);
+    function patchLchmod(fs6) {
+      fs6.lchmod = function(path3, mode, callback2) {
+        fs6.open(path3, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
           if (err) {
             if (callback2)
               callback2(err);
             return;
           }
-          fs5.fchmod(fd, mode, function(err2) {
-            fs5.close(fd, function(err22) {
+          fs6.fchmod(fd, mode, function(err2) {
+            fs6.close(fd, function(err22) {
               if (callback2)
                 callback2(err2 || err22);
             });
           });
         });
       };
-      fs5.lchmodSync = function(path3, mode) {
-        var fd = fs5.openSync(path3, constants.O_WRONLY | constants.O_SYMLINK, mode);
+      fs6.lchmodSync = function(path3, mode) {
+        var fd = fs6.openSync(path3, constants.O_WRONLY | constants.O_SYMLINK, mode);
         var threw = true;
         var ret;
         try {
-          ret = fs5.fchmodSync(fd, mode);
+          ret = fs6.fchmodSync(fd, mode);
           threw = false;
         } finally {
           if (threw) {
             try {
-              fs5.closeSync(fd);
+              fs6.closeSync(fd);
             } catch (er2) {}
           } else {
-            fs5.closeSync(fd);
+            fs6.closeSync(fd);
           }
         }
         return ret;
       };
     }
-    function patchLutimes(fs5) {
-      if (constants.hasOwnProperty("O_SYMLINK") && fs5.futimes) {
-        fs5.lutimes = function(path3, at2, mt2, cb) {
-          fs5.open(path3, constants.O_SYMLINK, function(er2, fd) {
+    function patchLutimes(fs6) {
+      if (constants.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
+        fs6.lutimes = function(path3, at2, mt2, cb) {
+          fs6.open(path3, constants.O_SYMLINK, function(er2, fd) {
             if (er2) {
               if (cb)
                 cb(er2);
               return;
             }
-            fs5.futimes(fd, at2, mt2, function(er3) {
-              fs5.close(fd, function(er22) {
+            fs6.futimes(fd, at2, mt2, function(er3) {
+              fs6.close(fd, function(er22) {
                 if (cb)
                   cb(er3 || er22);
               });
             });
           });
         };
-        fs5.lutimesSync = function(path3, at2, mt2) {
-          var fd = fs5.openSync(path3, constants.O_SYMLINK);
+        fs6.lutimesSync = function(path3, at2, mt2) {
+          var fd = fs6.openSync(path3, constants.O_SYMLINK);
           var ret;
           var threw = true;
           try {
-            ret = fs5.futimesSync(fd, at2, mt2);
+            ret = fs6.futimesSync(fd, at2, mt2);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs5.closeSync(fd);
+                fs6.closeSync(fd);
               } catch (er2) {}
             } else {
-              fs5.closeSync(fd);
+              fs6.closeSync(fd);
             }
           }
           return ret;
         };
-      } else if (fs5.futimes) {
-        fs5.lutimes = function(_a3, _b, _c, cb) {
+      } else if (fs6.futimes) {
+        fs6.lutimes = function(_a3, _b, _c, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs5.lutimesSync = function() {};
+        fs6.lutimesSync = function() {};
       }
     }
     function chmodFix(orig) {
       if (!orig)
         return orig;
       return function(target, mode, cb) {
-        return orig.call(fs4, target, mode, function(er2) {
+        return orig.call(fs5, target, mode, function(er2) {
           if (chownErOk(er2))
             er2 = null;
           if (cb)
@@ -22399,7 +22399,7 @@ var require_polyfills = __commonJS((exports, module) => {
         return orig;
       return function(target, mode) {
         try {
-          return orig.call(fs4, target, mode);
+          return orig.call(fs5, target, mode);
         } catch (er2) {
           if (!chownErOk(er2))
             throw er2;
@@ -22410,7 +22410,7 @@ var require_polyfills = __commonJS((exports, module) => {
       if (!orig)
         return orig;
       return function(target, uid, gid, cb) {
-        return orig.call(fs4, target, uid, gid, function(er2) {
+        return orig.call(fs5, target, uid, gid, function(er2) {
           if (chownErOk(er2))
             er2 = null;
           if (cb)
@@ -22423,7 +22423,7 @@ var require_polyfills = __commonJS((exports, module) => {
         return orig;
       return function(target, uid, gid) {
         try {
-          return orig.call(fs4, target, uid, gid);
+          return orig.call(fs5, target, uid, gid);
         } catch (er2) {
           if (!chownErOk(er2))
             throw er2;
@@ -22448,14 +22448,14 @@ var require_polyfills = __commonJS((exports, module) => {
           if (cb)
             cb.apply(this, arguments);
         }
-        return options ? orig.call(fs4, target, options, callback2) : orig.call(fs4, target, callback2);
+        return options ? orig.call(fs5, target, options, callback2) : orig.call(fs5, target, callback2);
       };
     }
     function statFixSync(orig) {
       if (!orig)
         return orig;
       return function(target, options) {
-        var stats = options ? orig.call(fs4, target, options) : orig.call(fs4, target);
+        var stats = options ? orig.call(fs5, target, options) : orig.call(fs5, target);
         if (stats) {
           if (stats.uid < 0)
             stats.uid += 4294967296;
@@ -22484,7 +22484,7 @@ var require_polyfills = __commonJS((exports, module) => {
 var require_legacy_streams = __commonJS((exports, module) => {
   var Stream = __require("stream").Stream;
   module.exports = legacy;
-  function legacy(fs4) {
+  function legacy(fs5) {
     return {
       ReadStream: ReadStream2,
       WriteStream
@@ -22529,7 +22529,7 @@ var require_legacy_streams = __commonJS((exports, module) => {
         });
         return;
       }
-      fs4.open(this.path, this.flags, this.mode, function(err, fd) {
+      fs5.open(this.path, this.flags, this.mode, function(err, fd) {
         if (err) {
           self2.emit("error", err);
           self2.readable = false;
@@ -22569,7 +22569,7 @@ var require_legacy_streams = __commonJS((exports, module) => {
       this.busy = false;
       this._queue = [];
       if (this.fd === null) {
-        this._open = fs4.open;
+        this._open = fs5.open;
         this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
         this.flush();
       }
@@ -22599,7 +22599,7 @@ var require_clone = __commonJS((exports, module) => {
 
 // node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS((exports, module) => {
-  var fs4 = __require("fs");
+  var fs5 = __require("fs");
   var polyfills = require_polyfills();
   var legacy = require_legacy_streams();
   var clone2 = require_clone();
@@ -22631,12 +22631,12 @@ var require_graceful_fs = __commonJS((exports, module) => {
 GFS4: `);
       console.error(m4);
     };
-  if (!fs4[gracefulQueue]) {
+  if (!fs5[gracefulQueue]) {
     queue = global[gracefulQueue] || [];
-    publishQueue(fs4, queue);
-    fs4.close = function(fs$close) {
+    publishQueue(fs5, queue);
+    fs5.close = function(fs$close) {
       function close(fd, cb) {
-        return fs$close.call(fs4, fd, function(err) {
+        return fs$close.call(fs5, fd, function(err) {
           if (!err) {
             resetQueue();
           }
@@ -22648,40 +22648,40 @@ GFS4: `);
         value: fs$close
       });
       return close;
-    }(fs4.close);
-    fs4.closeSync = function(fs$closeSync) {
+    }(fs5.close);
+    fs5.closeSync = function(fs$closeSync) {
       function closeSync(fd) {
-        fs$closeSync.apply(fs4, arguments);
+        fs$closeSync.apply(fs5, arguments);
         resetQueue();
       }
       Object.defineProperty(closeSync, previousSymbol, {
         value: fs$closeSync
       });
       return closeSync;
-    }(fs4.closeSync);
+    }(fs5.closeSync);
     if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
       process.on("exit", function() {
-        debug(fs4[gracefulQueue]);
-        __require("assert").equal(fs4[gracefulQueue].length, 0);
+        debug(fs5[gracefulQueue]);
+        __require("assert").equal(fs5[gracefulQueue].length, 0);
       });
     }
   }
   var queue;
   if (!global[gracefulQueue]) {
-    publishQueue(global, fs4[gracefulQueue]);
-  }
-  module.exports = patch(clone2(fs4));
-  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs4.__patched) {
-    module.exports = patch(fs4);
-    fs4.__patched = true;
-  }
-  function patch(fs5) {
-    polyfills(fs5);
-    fs5.gracefulify = patch;
-    fs5.createReadStream = createReadStream2;
-    fs5.createWriteStream = createWriteStream;
-    var fs$readFile = fs5.readFile;
-    fs5.readFile = readFile;
+    publishQueue(global, fs5[gracefulQueue]);
+  }
+  module.exports = patch(clone2(fs5));
+  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs5.__patched) {
+    module.exports = patch(fs5);
+    fs5.__patched = true;
+  }
+  function patch(fs6) {
+    polyfills(fs6);
+    fs6.gracefulify = patch;
+    fs6.createReadStream = createReadStream2;
+    fs6.createWriteStream = createWriteStream;
+    var fs$readFile = fs6.readFile;
+    fs6.readFile = readFile;
     function readFile(path3, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
@@ -22697,8 +22697,8 @@ GFS4: `);
         });
       }
     }
-    var fs$writeFile = fs5.writeFile;
-    fs5.writeFile = writeFile;
+    var fs$writeFile = fs6.writeFile;
+    fs6.writeFile = writeFile;
     function writeFile(path3, data, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
@@ -22714,9 +22714,9 @@ GFS4: `);
         });
       }
     }
-    var fs$appendFile = fs5.appendFile;
+    var fs$appendFile = fs6.appendFile;
     if (fs$appendFile)
-      fs5.appendFile = appendFile;
+      fs6.appendFile = appendFile;
     function appendFile(path3, data, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
@@ -22732,9 +22732,9 @@ GFS4: `);
         });
       }
     }
-    var fs$copyFile = fs5.copyFile;
+    var fs$copyFile = fs6.copyFile;
     if (fs$copyFile)
-      fs5.copyFile = copyFile;
+      fs6.copyFile = copyFile;
     function copyFile(src, dest, flags, cb) {
       if (typeof flags === "function") {
         cb = flags;
@@ -22752,8 +22752,8 @@ GFS4: `);
         });
       }
     }
-    var fs$readdir = fs5.readdir;
-    fs5.readdir = readdir3;
+    var fs$readdir = fs6.readdir;
+    fs6.readdir = readdir3;
     var noReaddirOptionVersions = /^v[0-5]\./;
     function readdir3(path3, options, cb) {
       if (typeof options === "function")
@@ -22784,21 +22784,21 @@ GFS4: `);
       }
     }
     if (process.version.substr(0, 4) === "v0.8") {
-      var legStreams = legacy(fs5);
+      var legStreams = legacy(fs6);
       ReadStream2 = legStreams.ReadStream;
       WriteStream = legStreams.WriteStream;
     }
-    var fs$ReadStream = fs5.ReadStream;
+    var fs$ReadStream = fs6.ReadStream;
     if (fs$ReadStream) {
       ReadStream2.prototype = Object.create(fs$ReadStream.prototype);
       ReadStream2.prototype.open = ReadStream$open;
     }
-    var fs$WriteStream = fs5.WriteStream;
+    var fs$WriteStream = fs6.WriteStream;
     if (fs$WriteStream) {
       WriteStream.prototype = Object.create(fs$WriteStream.prototype);
       WriteStream.prototype.open = WriteStream$open;
     }
-    Object.defineProperty(fs5, "ReadStream", {
+    Object.defineProperty(fs6, "ReadStream", {
       get: function() {
         return ReadStream2;
       },
@@ -22808,7 +22808,7 @@ GFS4: `);
       enumerable: true,
       configurable: true
     });
-    Object.defineProperty(fs5, "WriteStream", {
+    Object.defineProperty(fs6, "WriteStream", {
       get: function() {
         return WriteStream;
       },
@@ -22819,7 +22819,7 @@ GFS4: `);
       configurable: true
     });
     var FileReadStream = ReadStream2;
-    Object.defineProperty(fs5, "FileReadStream", {
+    Object.defineProperty(fs6, "FileReadStream", {
       get: function() {
         return FileReadStream;
       },
@@ -22830,7 +22830,7 @@ GFS4: `);
       configurable: true
     });
     var FileWriteStream = WriteStream;
-    Object.defineProperty(fs5, "FileWriteStream", {
+    Object.defineProperty(fs6, "FileWriteStream", {
       get: function() {
         return FileWriteStream;
       },
@@ -22879,13 +22879,13 @@ GFS4: `);
       });
     }
     function createReadStream2(path3, options) {
-      return new fs5.ReadStream(path3, options);
+      return new fs6.ReadStream(path3, options);
     }
     function createWriteStream(path3, options) {
-      return new fs5.WriteStream(path3, options);
+      return new fs6.WriteStream(path3, options);
     }
-    var fs$open = fs5.open;
-    fs5.open = open;
+    var fs$open = fs6.open;
+    fs6.open = open;
     function open(path3, flags, mode, cb) {
       if (typeof mode === "function")
         cb = mode, mode = null;
@@ -22901,20 +22901,20 @@ GFS4: `);
         });
       }
     }
-    return fs5;
+    return fs6;
   }
   function enqueue(elem) {
     debug("ENQUEUE", elem[0].name, elem[1]);
-    fs4[gracefulQueue].push(elem);
+    fs5[gracefulQueue].push(elem);
     retry();
   }
   var retryTimer;
   function resetQueue() {
     var now = Date.now();
-    for (var i2 = 0;i2 < fs4[gracefulQueue].length; ++i2) {
-      if (fs4[gracefulQueue][i2].length > 2) {
-        fs4[gracefulQueue][i2][3] = now;
-        fs4[gracefulQueue][i2][4] = now;
+    for (var i2 = 0;i2 < fs5[gracefulQueue].length; ++i2) {
+      if (fs5[gracefulQueue][i2].length > 2) {
+        fs5[gracefulQueue][i2][3] = now;
+        fs5[gracefulQueue][i2][4] = now;
       }
     }
     retry();
@@ -22922,9 +22922,9 @@ GFS4: `);
   function retry() {
     clearTimeout(retryTimer);
     retryTimer = undefined;
-    if (fs4[gracefulQueue].length === 0)
+    if (fs5[gracefulQueue].length === 0)
       return;
-    var elem = fs4[gracefulQueue].shift();
+    var elem = fs5[gracefulQueue].shift();
     var fn2 = elem[0];
     var args = elem[1];
     var err = elem[2];
@@ -22946,7 +22946,7 @@ GFS4: `);
         debug("RETRY", fn2.name, args);
         fn2.apply(null, args.concat([startTime]));
       } else {
-        fs4[gracefulQueue].push(elem);
+        fs5[gracefulQueue].push(elem);
       }
     }
     if (retryTimer === undefined) {
@@ -31598,7 +31598,7 @@ var require_stream = __commonJS((exports, module) => {
   var { pipeline } = require_pipeline();
   var { destroyer } = require_destroy3();
   var eos = require_end_of_stream();
-  var promises2 = require_promises();
+  var promises3 = require_promises();
   var utils = require_utils3();
   var Stream = module.exports = require_legacy().Stream;
   Stream.isDestroyed = utils.isDestroyed;
@@ -31672,21 +31672,21 @@ var require_stream = __commonJS((exports, module) => {
     configurable: true,
     enumerable: true,
     get() {
-      return promises2;
+      return promises3;
     }
   });
   ObjectDefineProperty(pipeline, customPromisify, {
     __proto__: null,
     enumerable: true,
     get() {
-      return promises2.pipeline;
+      return promises3.pipeline;
     }
   });
   ObjectDefineProperty(eos, customPromisify, {
     __proto__: null,
     enumerable: true,
     get() {
-      return promises2.finished;
+      return promises3.finished;
     }
   });
   Stream.Stream = Stream;
@@ -31702,7 +31702,7 @@ var require_stream = __commonJS((exports, module) => {
 var require_ours = __commonJS((exports, module) => {
   var Stream = __require("stream");
   if (Stream && process.env.READABLE_STREAM === "disable") {
-    const promises2 = Stream.promises;
+    const promises3 = Stream.promises;
     module.exports._uint8ArrayToBuffer = Stream._uint8ArrayToBuffer;
     module.exports._isUint8Array = Stream._isUint8Array;
     module.exports.isDisturbed = Stream.isDisturbed;
@@ -31722,13 +31722,13 @@ var require_ours = __commonJS((exports, module) => {
       configurable: true,
       enumerable: true,
       get() {
-        return promises2;
+        return promises3;
       }
     });
     module.exports.Stream = Stream.Stream;
   } else {
     const CustomStream = require_stream();
-    const promises2 = require_promises();
+    const promises3 = require_promises();
     const originalDestroy = CustomStream.Readable.destroy;
     module.exports = CustomStream.Readable;
     module.exports._uint8ArrayToBuffer = CustomStream._uint8ArrayToBuffer;
@@ -31751,7 +31751,7 @@ var require_ours = __commonJS((exports, module) => {
       configurable: true,
       enumerable: true,
       get() {
-        return promises2;
+        return promises3;
       }
     });
     module.exports.Stream = CustomStream.Stream;
@@ -36757,8 +36757,8 @@ var require_commonjs4 = __commonJS((exports) => {
     #children;
     nocase;
     #fs;
-    constructor(cwd = process.cwd(), pathImpl, sep5, { nocase, childrenCacheSize = 16 * 1024, fs: fs4 = defaultFS } = {}) {
-      this.#fs = fsFromOption(fs4);
+    constructor(cwd = process.cwd(), pathImpl, sep5, { nocase, childrenCacheSize = 16 * 1024, fs: fs5 = defaultFS } = {}) {
+      this.#fs = fsFromOption(fs5);
       if (cwd instanceof URL || cwd.startsWith("file://")) {
         cwd = (0, node_url_1.fileURLToPath)(cwd);
       }
@@ -37121,14 +37121,14 @@ var require_commonjs4 = __commonJS((exports) => {
             if (er2)
               return results.emit("error", er2);
             if (follow && !didRealpaths) {
-              const promises2 = [];
+              const promises3 = [];
               for (const e of entries) {
                 if (e.isSymbolicLink()) {
-                  promises2.push(e.realpath().then((r2) => r2?.isUnknown() ? r2.lstat() : r2));
+                  promises3.push(e.realpath().then((r2) => r2?.isUnknown() ? r2.lstat() : r2));
                 }
               }
-              if (promises2.length) {
-                Promise.all(promises2).then(() => onReaddir(null, entries, true));
+              if (promises3.length) {
+                Promise.all(promises3).then(() => onReaddir(null, entries, true));
                 return;
               }
             }
@@ -37235,8 +37235,8 @@ var require_commonjs4 = __commonJS((exports) => {
     parseRootPath(dir) {
       return node_path_1.win32.parse(dir).root.toUpperCase();
     }
-    newRoot(fs4) {
-      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs4 });
+    newRoot(fs5) {
+      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs5 });
     }
     isAbsolute(p3) {
       return p3.startsWith("/") || p3.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p3);
@@ -37254,8 +37254,8 @@ var require_commonjs4 = __commonJS((exports) => {
     parseRootPath(_dir) {
       return "/";
     }
-    newRoot(fs4) {
-      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs4 });
+    newRoot(fs5) {
+      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs5 });
     }
     isAbsolute(p3) {
       return p3.startsWith("/");
@@ -38341,7 +38341,7 @@ var require_commonjs5 = __commonJS((exports) => {
 
 // node_modules/archiver-utils/file.js
 var require_file = __commonJS((exports, module) => {
-  var fs4 = require_graceful_fs();
+  var fs5 = require_graceful_fs();
   var path3 = __require("path");
   var flatten = require_flatten();
   var difference = require_difference();
@@ -38368,7 +38368,7 @@ var require_file = __commonJS((exports, module) => {
   };
   file2.exists = function() {
     var filepath = path3.join.apply(path3, arguments);
-    return fs4.existsSync(filepath);
+    return fs5.existsSync(filepath);
   };
   file2.expand = function(...args) {
     var options = isPlainObject4(args[0]) ? args.shift() : {};
@@ -38386,7 +38386,7 @@ var require_file = __commonJS((exports, module) => {
           if (typeof options.filter === "function") {
             return options.filter(filepath);
           } else {
-            return fs4.statSync(filepath)[options.filter]();
+            return fs5.statSync(filepath)[options.filter]();
           }
         } catch (e) {
           return false;
@@ -38492,7 +38492,7 @@ var require_file = __commonJS((exports, module) => {
 
 // node_modules/archiver-utils/index.js
 var require_archiver_utils = __commonJS((exports, module) => {
-  var fs4 = require_graceful_fs();
+  var fs5 = require_graceful_fs();
   var path3 = __require("path");
   var isStream = require_is_stream();
   var lazystream = require_lazystream();
@@ -38541,7 +38541,7 @@ var require_archiver_utils = __commonJS((exports, module) => {
   };
   utils.lazyReadStream = function(filepath) {
     return new lazystream.Readable(function() {
-      return fs4.createReadStream(filepath);
+      return fs5.createReadStream(filepath);
     });
   };
   utils.normalizeInputSource = function(source) {
@@ -38569,7 +38569,7 @@ var require_archiver_utils = __commonJS((exports, module) => {
       callback2 = base;
       base = dirpath;
     }
-    fs4.readdir(dirpath, function(err, list) {
+    fs5.readdir(dirpath, function(err, list) {
       var i2 = 0;
       var file2;
       var filepath;
@@ -38582,7 +38582,7 @@ var require_archiver_utils = __commonJS((exports, module) => {
           return callback2(null, results);
         }
         filepath = path3.join(dirpath, file2);
-        fs4.stat(filepath, function(err2, stats) {
+        fs5.stat(filepath, function(err2, stats) {
           results.push({
             path: filepath,
             relative: path3.relative(base, filepath).replace(/\\/g, "/"),
@@ -43829,7 +43829,7 @@ var require_stream2 = __commonJS((exports, module) => {
   var { pipeline } = require_pipeline2();
   var { destroyer } = require_destroy4();
   var eos = require_end_of_stream2();
-  var promises2 = require_promises2();
+  var promises3 = require_promises2();
   var utils = require_utils4();
   var Stream = module.exports = require_legacy2().Stream;
   Stream.isDestroyed = utils.isDestroyed;
@@ -43903,21 +43903,21 @@ var require_stream2 = __commonJS((exports, module) => {
     configurable: true,
     enumerable: true,
     get() {
-      return promises2;
+      return promises3;
     }
   });
   ObjectDefineProperty(pipeline, customPromisify, {
     __proto__: null,
     enumerable: true,
     get() {
-      return promises2.pipeline;
+      return promises3.pipeline;
     }
   });
   ObjectDefineProperty(eos, customPromisify, {
     __proto__: null,
     enumerable: true,
     get() {
-      return promises2.finished;
+      return promises3.finished;
     }
   });
   Stream.Stream = Stream;
@@ -43933,7 +43933,7 @@ var require_stream2 = __commonJS((exports, module) => {
 var require_ours2 = __commonJS((exports, module) => {
   var Stream = __require("stream");
   if (Stream && process.env.READABLE_STREAM === "disable") {
-    const promises2 = Stream.promises;
+    const promises3 = Stream.promises;
     module.exports._uint8ArrayToBuffer = Stream._uint8ArrayToBuffer;
     module.exports._isUint8Array = Stream._isUint8Array;
     module.exports.isDisturbed = Stream.isDisturbed;
@@ -43953,13 +43953,13 @@ var require_ours2 = __commonJS((exports, module) => {
       configurable: true,
       enumerable: true,
       get() {
-        return promises2;
+        return promises3;
       }
     });
     module.exports.Stream = Stream.Stream;
   } else {
     const CustomStream = require_stream2();
-    const promises2 = require_promises2();
+    const promises3 = require_promises2();
     const originalDestroy = CustomStream.Readable.destroy;
     module.exports = CustomStream.Readable;
     module.exports._uint8ArrayToBuffer = CustomStream._uint8ArrayToBuffer;
@@ -43982,7 +43982,7 @@ var require_ours2 = __commonJS((exports, module) => {
       configurable: true,
       enumerable: true,
       get() {
-        return promises2;
+        return promises3;
       }
     });
     module.exports.Stream = CustomStream.Stream;
@@ -43992,7 +43992,7 @@ var require_ours2 = __commonJS((exports, module) => {
 
 // node_modules/archiver/lib/core.js
 var require_core = __commonJS((exports, module) => {
-  var fs4 = __require("fs");
+  var fs5 = __require("fs");
   var glob2 = require_readdir_glob();
   var async = require_async();
   var path3 = __require("path");
@@ -44056,7 +44056,7 @@ var require_core = __commonJS((exports, module) => {
     data.sourcePath = filepath;
     task.data = data;
     this._entriesCount++;
-    if (data.stats && data.stats instanceof fs4.Stats) {
+    if (data.stats && data.stats instanceof fs5.Stats) {
       task = this._updateQueueTaskWithStats(task, data.stats);
       if (task) {
         if (data.stats.size) {
@@ -44227,7 +44227,7 @@ var require_core = __commonJS((exports, module) => {
       callback2();
       return;
     }
-    fs4.lstat(task.filepath, function(err, stats) {
+    fs5.lstat(task.filepath, function(err, stats) {
       if (this._state.aborted) {
         setImmediate(callback2);
         return;
@@ -44270,7 +44270,7 @@ var require_core = __commonJS((exports, module) => {
       task.data.sourceType = "buffer";
       task.source = Buffer.concat([]);
     } else if (stats.isSymbolicLink() && this._moduleSupports("symlink")) {
-      var linkPath = fs4.readlinkSync(task.filepath);
+      var linkPath = fs5.readlinkSync(task.filepath);
       var dirName = path3.dirname(task.filepath);
       task.data.type = "symlink";
       task.data.linkname = path3.relative(dirName, path3.resolve(dirName, linkPath));
@@ -50092,7 +50092,7 @@ var require_stream3 = __commonJS((exports, module) => {
   var { pipeline } = require_pipeline3();
   var { destroyer } = require_destroy5();
   var eos = require_end_of_stream3();
-  var promises2 = require_promises3();
+  var promises3 = require_promises3();
   var utils = require_utils5();
   var Stream = module.exports = require_legacy3().Stream;
   Stream.isDestroyed = utils.isDestroyed;
@@ -50166,21 +50166,21 @@ var require_stream3 = __commonJS((exports, module) => {
     configurable: true,
     enumerable: true,
     get() {
-      return promises2;
+      return promises3;
     }
   });
   ObjectDefineProperty(pipeline, customPromisify, {
     __proto__: null,
     enumerable: true,
     get() {
-      return promises2.pipeline;
+      return promises3.pipeline;
     }
   });
   ObjectDefineProperty(eos, customPromisify, {
     __proto__: null,
     enumerable: true,
     get() {
-      return promises2.finished;
+      return promises3.finished;
     }
   });
   Stream.Stream = Stream;
@@ -50196,7 +50196,7 @@ var require_stream3 = __commonJS((exports, module) => {
 var require_ours3 = __commonJS((exports, module) => {
   var Stream = __require("stream");
   if (Stream && process.env.READABLE_STREAM === "disable") {
-    const promises2 = Stream.promises;
+    const promises3 = Stream.promises;
     module.exports._uint8ArrayToBuffer = Stream._uint8ArrayToBuffer;
     module.exports._isUint8Array = Stream._isUint8Array;
     module.exports.isDisturbed = Stream.isDisturbed;
@@ -50216,13 +50216,13 @@ var require_ours3 = __commonJS((exports, module) => {
       configurable: true,
       enumerable: true,
       get() {
-        return promises2;
+        return promises3;
       }
     });
     module.exports.Stream = Stream.Stream;
   } else {
     const CustomStream = require_stream3();
-    const promises2 = require_promises3();
+    const promises3 = require_promises3();
     const originalDestroy = CustomStream.Readable.destroy;
     module.exports = CustomStream.Readable;
     module.exports._uint8ArrayToBuffer = CustomStream._uint8ArrayToBuffer;
@@ -50245,7 +50245,7 @@ var require_ours3 = __commonJS((exports, module) => {
       configurable: true,
       enumerable: true,
       get() {
-        return promises2;
+        return promises3;
       }
     });
     module.exports.Stream = CustomStream.Stream;
@@ -55649,7 +55649,7 @@ var require_stream4 = __commonJS((exports, module) => {
   var { pipeline } = require_pipeline4();
   var { destroyer } = require_destroy6();
   var eos = require_end_of_stream4();
-  var promises2 = require_promises4();
+  var promises3 = require_promises4();
   var utils = require_utils6();
   var Stream = module.exports = require_legacy4().Stream;
   Stream.isDestroyed = utils.isDestroyed;
@@ -55723,21 +55723,21 @@ var require_stream4 = __commonJS((exports, module) => {
     configurable: true,
     enumerable: true,
     get() {
-      return promises2;
+      return promises3;
     }
   });
   ObjectDefineProperty(pipeline, customPromisify, {
     __proto__: null,
     enumerable: true,
     get() {
-      return promises2.pipeline;
+      return promises3.pipeline;
     }
   });
   ObjectDefineProperty(eos, customPromisify, {
     __proto__: null,
     enumerable: true,
     get() {
-      return promises2.finished;
+      return promises3.finished;
     }
   });
   Stream.Stream = Stream;
@@ -55753,7 +55753,7 @@ var require_stream4 = __commonJS((exports, module) => {
 var require_ours4 = __commonJS((exports, module) => {
   var Stream = __require("stream");
   if (Stream && process.env.READABLE_STREAM === "disable") {
-    const promises2 = Stream.promises;
+    const promises3 = Stream.promises;
     module.exports._uint8ArrayToBuffer = Stream._uint8ArrayToBuffer;
     module.exports._isUint8Array = Stream._isUint8Array;
     module.exports.isDisturbed = Stream.isDisturbed;
@@ -55773,13 +55773,13 @@ var require_ours4 = __commonJS((exports, module) => {
       configurable: true,
       enumerable: true,
       get() {
-        return promises2;
+        return promises3;
       }
     });
     module.exports.Stream = Stream.Stream;
   } else {
     const CustomStream = require_stream4();
-    const promises2 = require_promises4();
+    const promises3 = require_promises4();
     const originalDestroy = CustomStream.Readable.destroy;
     module.exports = CustomStream.Readable;
     module.exports._uint8ArrayToBuffer = CustomStream._uint8ArrayToBuffer;
@@ -55802,7 +55802,7 @@ var require_ours4 = __commonJS((exports, module) => {
       configurable: true,
       enumerable: true,
       get() {
-        return promises2;
+        return promises3;
       }
     });
     module.exports.Stream = CustomStream.Stream;
@@ -59364,7 +59364,7 @@ function mitt_default(n2) {
 }
 
 // node_modules/@wdio/utils/build/index.js
-import fs4 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 import path3 from "node:path";
 function overwriteElementCommands(propertiesObject) {
   const elementOverrides = propertiesObject.__elementOverrides__ ? propertiesObject.__elementOverrides__.value : {};
@@ -59497,7 +59497,7 @@ async function enableFileLogging(outputDir) {
   if (!outputDir) {
     return;
   }
-  await fs4.mkdir(path3.join(outputDir), { recursive: true });
+  await fs5.mkdir(path3.join(outputDir), { recursive: true });
   process.env.WDIO_LOG_PATH = path3.join(outputDir, "wdio.log");
 }
 function WebDriver(options, modifier, propertiesObject = {}) {
@@ -88613,19 +88613,19 @@ async function connectWebsocket(candidateUrls, options) {
   }
   return;
 }
-function firstResolved(promises2, errorMessages = []) {
-  if (promises2.length === 0) {
+function firstResolved(promises3, errorMessages = []) {
+  if (promises3.length === 0) {
     const sep5 = `
   - `;
     const errorMessage2 = errorMessages.length > 0 ? sep5 + errorMessages.join(sep5) : "";
     log6.error("Could not connect to Bidi protocol" + errorMessage2);
     return Promise.resolve(undefined);
   }
-  return Promise.race(promises2.map(({ promise: promise3 }) => promise3)).then((result) => {
+  return Promise.race(promises3.map(({ promise: promise3 }) => promise3)).then((result) => {
     if (result.isConnected) {
       return result;
     }
-    return firstResolved(promises2.filter(({ index }) => index !== result.index), [...errorMessages, result.errorMessage || "unknown error"]);
+    return firstResolved(promises3.filter(({ index }) => index !== result.index), [...errorMessages, result.errorMessage || "unknown error"]);
   });
 }
 function killDriverProcess(capabilities, shutdownDriver) {
@@ -131304,18 +131304,18 @@ var require_proxy_agent2 = __commonJS((exports, module) => {
       }
     }
     [kClose]() {
-      const promises2 = [this[kAgent].close()];
+      const promises3 = [this[kAgent].close()];
       if (this[kClient]) {
-        promises2.push(this[kClient].close());
+        promises3.push(this[kClient].close());
       }
-      return Promise.all(promises2);
+      return Promise.all(promises3);
     }
     [kDestroy]() {
-      const promises2 = [this[kAgent].destroy()];
+      const promises3 = [this[kAgent].destroy()];
       if (this[kClient]) {
-        promises2.push(this[kClient].destroy());
+        promises3.push(this[kClient].destroy());
       }
-      return Promise.all(promises2);
+      return Promise.all(promises3);
     }
   }
   function buildHeaders(headers) {
@@ -144419,7 +144419,7 @@ __export(exports_node, {
 import os5 from "node:os";
 import fs8 from "node:fs";
 import process22 from "node:process";
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import path4 from "node:path";
 import fs32 from "node:fs";
 import path32 from "node:path";
@@ -144429,7 +144429,7 @@ import fs42 from "node:fs";
 import path42 from "node:path";
 import fs52 from "node:fs";
 import path5 from "node:path";
-import fs6 from "node:fs/promises";
+import fs62 from "node:fs/promises";
 import path6 from "node:path";
 import fs7 from "node:fs/promises";
 import path7 from "node:path";
@@ -144445,12 +144445,12 @@ async function downloadFile(fileName, targetDirectory) {
   if (!targetDirectory.endsWith("/")) {
     targetDirectory += "/";
   }
-  fs5.mkdirSync(targetDirectory, { recursive: true });
+  fs6.mkdirSync(targetDirectory, { recursive: true });
   const zipFilePath = path4.join(targetDirectory, `${fileName}.zip`);
   const binaryString = atob(base64Content);
   const bytes = Uint8Array.from(binaryString, (char) => char.charCodeAt(0));
-  fs5.writeFileSync(zipFilePath, bytes);
-  const zipData = fs5.readFileSync(zipFilePath);
+  fs6.writeFileSync(zipFilePath, bytes);
+  const zipData = fs6.readFileSync(zipFilePath);
   const filesData = [];
   try {
     const zip2 = await import_jszip.default.loadAsync(zipData);
@@ -144458,7 +144458,7 @@ async function downloadFile(fileName, targetDirectory) {
     for (let i2 = 0;i2 < keys2.length; i2++) {
       const fileData = await zip2.files[keys2[i2]].async("nodebuffer");
       const dir = path4.resolve(targetDirectory, keys2[i2]);
-      fs5.writeFileSync(dir, fileData);
+      fs6.writeFileSync(dir, fileData);
       log8.info(`File extracted: ${keys2[i2]}`);
       filesData.push(dir);
     }
@@ -144580,7 +144580,7 @@ async function saveScreenshot(filepath, options) {
   await assertDirectoryExists(absoluteFilepath);
   const screenBuffer = this.isBidi ? await takeScreenshotBidi.call(this, filepath, options) : await takeScreenshotClassic.call(this, filepath, options);
   const screenshot = Buffer.from(screenBuffer, "base64");
-  await fs6.writeFile(absoluteFilepath, screenshot);
+  await fs62.writeFile(absoluteFilepath, screenshot);
   return screenshot;
 }
 function takeScreenshotClassic(filepath, options) {
@@ -155198,7 +155198,7 @@ var authMessages = {
       linkExpired: "The flow bundle download link has expired. Please run `qawolf flows pull` again to refresh.",
       failedWithStatus: (status) => `Could not download the flow bundle (HTTP ${status}).`,
       networkUnreachable: "Could not reach the flow bundle storage. Check your network connection and try again.",
-      timedOut: (timeoutMs) => `Downloading the flow bundle timed out after ${formatSeconds(timeoutMs)}. Please try again.`,
+      timedOut: (timeoutMs) => `Downloading the flow bundle stalled — no data arrived for ${formatSeconds(timeoutMs)}. Please try again.`,
       malformed: "The flow bundle download was malformed. Please run `qawolf flows pull` again."
     }
   },
@@ -155345,6 +155345,7 @@ var flowsMessages = {
     aborted: "Aborted; no changes.",
     extractingBundle: "Extracting bundle",
     downloadingTeamStorageAssets: "Downloading team-storage assets",
+    downloadingTeamStorageAssetsProgress: (current, total) => `Downloading team-storage assets (${String(current)}/${String(total)})`,
     teamStorageRequiresTeamKey: "Team storage requires a team API key; organization keys are not supported here.",
     summary: (result, assetsAbs) => {
       const flows = pluralize(result.flowCount, "flow");
@@ -155639,10 +155640,33 @@ function flushAndExit(code, proc = process, scheduleBackstop = (fn) => {
 }
 
 // src/shell/fs.ts
+import * as fs2 from "node:fs";
+
+// src/shell/fsWriteHandle.ts
 import * as fs from "node:fs";
+async function openFsWriteHandle(path2) {
+  const handle = await fs.promises.open(path2, "w");
+  return {
+    async write(chunk) {
+      let remaining = chunk;
+      while (remaining.length > 0) {
+        const { bytesWritten } = await handle.write(remaining);
+        if (bytesWritten === 0) {
+          throw new Error(`write returned 0 bytes for '${path2}'`);
+        }
+        remaining = remaining.subarray(bytesWritten);
+      }
+    },
+    close() {
+      return handle.close();
+    }
+  };
+}
+
+// src/shell/fs.ts
 async function pathExists(p) {
   try {
-    await fs.promises.stat(p);
+    await fs2.promises.stat(p);
     return true;
   } catch (err) {
     if (isNoEntError(err))
@@ -155653,66 +155677,67 @@ async function pathExists(p) {
 function makeDefaultFs() {
   return {
     async mkdir(path2, options) {
-      await fs.promises.mkdir(path2, options);
+      await fs2.promises.mkdir(path2, options);
     },
     pathExists,
     readFile(path2) {
-      return fs.promises.readFile(path2, "utf-8");
+      return fs2.promises.readFile(path2, "utf-8");
     },
     async rm(path2, options) {
-      await fs.promises.rm(path2, options);
+      await fs2.promises.rm(path2, options);
     },
     stat(path2) {
-      return fs.promises.stat(path2);
+      return fs2.promises.stat(path2);
     },
     async unlink(path2) {
-      await fs.promises.unlink(path2);
+      await fs2.promises.unlink(path2);
     },
     async writeFile(path2, data, options) {
       if (typeof data === "string") {
-        await fs.promises.writeFile(path2, data, {
+        await fs2.promises.writeFile(path2, data, {
           encoding: "utf8",
           mode: options?.mode
         });
       } else {
-        await fs.promises.writeFile(path2, data, options ?? undefined);
+        await fs2.promises.writeFile(path2, data, options ?? undefined);
       }
     },
+    openWriteHandle: openFsWriteHandle,
     readdir(path2) {
-      return fs.promises.readdir(path2);
+      return fs2.promises.readdir(path2);
     },
     readdirWithTypes(path2) {
-      return fs.promises.readdir(path2, {
+      return fs2.promises.readdir(path2, {
         withFileTypes: true
       });
     },
     rename(oldPath, newPath) {
-      return fs.promises.rename(oldPath, newPath);
+      return fs2.promises.rename(oldPath, newPath);
     },
     utimes(path2, atime, mtime) {
-      return fs.promises.utimes(path2, atime, mtime);
+      return fs2.promises.utimes(path2, atime, mtime);
     },
     createReadStream(path2) {
-      if (!fs.existsSync(path2)) {
+      if (!fs2.existsSync(path2)) {
         const err = Object.assign(new Error(`ENOENT: no such file or directory, open '${path2}'`), { code: "ENOENT", errno: -2 });
         throw err;
       }
-      return fs.createReadStream(path2);
+      return fs2.createReadStream(path2);
     },
     async copyFile(source, destination) {
-      await fs.promises.copyFile(source, destination);
+      await fs2.promises.copyFile(source, destination);
     },
     existsSync(path2) {
-      return fs.existsSync(path2);
+      return fs2.existsSync(path2);
     },
     readFileSync(path2) {
-      return fs.readFileSync(path2, "utf-8");
+      return fs2.readFileSync(path2, "utf-8");
     },
     writeFileSync(path2, data) {
-      fs.writeFileSync(path2, data, "utf8");
+      fs2.writeFileSync(path2, data, "utf8");
     },
     mkdirSync(path2, options) {
-      fs.mkdirSync(path2, options);
+      fs2.mkdirSync(path2, options);
     }
   };
 }
@@ -155747,18 +155772,18 @@ function deleteFromKeychain() {
     return "unavailable";
   }
 }
-async function deleteFromFile(configDir, fs2) {
+async function deleteFromFile(configDir, fs3) {
   try {
-    await fs2.unlink(join2(configDir, credentialsFile));
+    await fs3.unlink(join2(configDir, credentialsFile));
     return "deleted";
   } catch {
     return "not-found";
   }
 }
-async function deleteApiKey(configDir, fs2) {
+async function deleteApiKey(configDir, fs3) {
   const [keychain, file] = await Promise.all([
     Promise.resolve(deleteFromKeychain()),
-    deleteFromFile(configDir, fs2)
+    deleteFromFile(configDir, fs3)
   ]);
   return { keychain, file };
 }
@@ -156536,8 +156561,8 @@ function getElementAtPath(obj, path2) {
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises2 = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises2).then((results) => {
+  const promises3 = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises3).then((results) => {
     const resolvedObj = {};
     for (let i = 0;i < keys.length; i++) {
       resolvedObj[keys[i]] = results[i];
@@ -170072,30 +170097,30 @@ async function loadApiKey(configDir, deps) {
 // src/domains/auth/store/save.ts
 import { join as join4 } from "node:path";
 import { Entry as Entry2 } from "@napi-rs/keyring";
-async function saveToFile(configDir, key, fs2) {
+async function saveToFile(configDir, key, fs3) {
   const payload = { apiKey: key };
-  await fs2.mkdir(configDir, { recursive: true, mode: 448 });
-  await fs2.writeFile(join4(configDir, credentialsFile), JSON.stringify(payload, undefined, 2), { mode: 384 });
+  await fs3.mkdir(configDir, { recursive: true, mode: 448 });
+  await fs3.writeFile(join4(configDir, credentialsFile), JSON.stringify(payload, undefined, 2), { mode: 384 });
 }
-async function saveApiKey(configDir, key, fs2) {
+async function saveApiKey(configDir, key, fs3) {
   try {
     const entry = new Entry2(service, account);
     entry.setPassword(key);
     return { stored: "keychain" };
   } catch (err) {
-    await saveToFile(configDir, key, fs2);
+    await saveToFile(configDir, key, fs3);
     return { stored: "file", keychainError: errorMessage(err) };
   }
 }
 // src/domains/auth/resolve.ts
-function makeDefaultDeps(fs2) {
+function makeDefaultDeps(fs3) {
   return {
-    loadApiKey: (configDir) => loadApiKey(configDir, { EntryClass: Entry3, fs: fs2 }),
+    loadApiKey: (configDir) => loadApiKey(configDir, { EntryClass: Entry3, fs: fs3 }),
     env: process.env
   };
 }
-async function resolveApiKey(configDir, fs2, deps) {
-  const resolvedDeps = deps ?? makeDefaultDeps(fs2);
+async function resolveApiKey(configDir, fs3, deps) {
+  const resolvedDeps = deps ?? makeDefaultDeps(fs3);
   const envKey = resolvedDeps.env["QAWOLF_API_KEY"];
   if (envKey?.trim()) {
     return { key: envKey.trim(), source: "env" };
@@ -170106,8 +170131,8 @@ async function resolveApiKey(configDir, fs2, deps) {
   }
   return;
 }
-async function requireApiKey(configDir, fs2, deps) {
-  const result = await resolveApiKey(configDir, fs2, deps);
+async function requireApiKey(configDir, fs3, deps) {
+  const result = await resolveApiKey(configDir, fs3, deps);
   if (!result) {
     throw new Error("QAWOLF_API_KEY is not set. Set it in your environment, or run 'qawolf auth login'. See 'qawolf doctor'.");
   }
@@ -170298,7 +170323,7 @@ function describeTeamStorageDownloadError(path2, err) {
     return `Could not reach team-storage while downloading ${path2}. Check your network connection and try again.`;
   }
   if (err.kind === "timeout") {
-    return `Downloading the team-storage asset ${path2} timed out after ${formatSeconds(err.timeoutMs)}. Please try again.`;
+    return `Downloading the team-storage asset ${path2} stalled — no data arrived for ${formatSeconds(err.timeoutMs)}. Please try again.`;
   }
   return `The team-storage download for ${path2} was malformed. Please run \`qawolf flows pull\` again.`;
 }
@@ -171242,47 +171267,87 @@ import { tmpdir as tmpdir2 } from "node:os";
 import { join as join6 } from "node:path";
 
 // src/shell/platform/fetchSignedUrl.ts
-var timeoutMs = 30000;
+var defaultStallTimeoutMs = 30000;
 async function fetchSignedUrl(args, deps = { fetch: globalThis.fetch }) {
-  let response;
+  const timeoutMs = deps.stallTimeoutMs ?? defaultStallTimeoutMs;
+  const fs3 = deps.fs ?? makeDefaultFs();
+  const partPath = `${args.dest}.part`;
+  const controller = new AbortController;
+  let stallTimer;
+  const armStallTimer = () => {
+    clearTimeout(stallTimer);
+    stallTimer = setTimeout(() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")), timeoutMs);
+  };
   try {
-    response = await deps.fetch(args.url, {
-      signal: AbortSignal.timeout(timeoutMs)
-    });
-  } catch (error51) {
-    if (isTimeoutError(error51)) {
-      return { ok: false, error: { kind: "timeout", timeoutMs } };
+    armStallTimer();
+    let response;
+    try {
+      response = await deps.fetch(args.url, { signal: controller.signal });
+    } catch (error51) {
+      if (isTimeoutError(error51)) {
+        return { ok: false, error: { kind: "timeout", timeoutMs } };
+      }
+      return { ok: false, error: { cause: toError(error51), kind: "network" } };
     }
-    return { ok: false, error: { cause: toError(error51), kind: "network" } };
-  }
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    return {
-      ok: false,
-      error: { body, kind: "http", status: response.status }
-    };
-  }
-  if (!response.body) {
-    return {
-      ok: false,
-      error: { cause: new Error("response had no body"), kind: "network" }
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      return {
+        ok: false,
+        error: { body, kind: "http", status: response.status }
+      };
+    }
+    if (!response.body) {
+      return {
+        ok: false,
+        error: { cause: new Error("response had no body"), kind: "network" }
+      };
+    }
+    let handle;
+    try {
+      handle = await fs3.openWriteHandle(partPath);
+    } catch (error51) {
+      controller.abort(toError(error51));
+      return { ok: false, error: { cause: toError(error51), kind: "network" } };
+    }
+    const discardPart = async () => {
+      await handle.close().catch(() => {});
+      await fs3.unlink(partPath).catch(() => {});
     };
-  }
-  let downloaded;
-  try {
-    downloaded = await response.arrayBuffer();
-  } catch (error51) {
-    if (isTimeoutError(error51)) {
-      return { ok: false, error: { kind: "timeout", timeoutMs } };
+    const reader = response.body.getReader();
+    for (;; ) {
+      let result;
+      try {
+        result = await reader.read();
+      } catch (error51) {
+        await discardPart();
+        if (isTimeoutError(error51)) {
+          return { ok: false, error: { kind: "timeout", timeoutMs } };
+        }
+        return { ok: false, error: { cause: toError(error51), kind: "network" } };
+      }
+      if (result.done)
+        break;
+      clearTimeout(stallTimer);
+      try {
+        await handle.write(result.value);
+      } catch (error51) {
+        controller.abort(toError(error51));
+        await discardPart();
+        return { ok: false, error: { cause: toError(error51), kind: "network" } };
+      }
+      armStallTimer();
     }
-    return { ok: false, error: { cause: toError(error51), kind: "network" } };
-  }
-  try {
-    await (deps.fs ?? makeDefaultFs()).writeFile(args.dest, new Uint8Array(downloaded));
-  } catch (error51) {
-    return { ok: false, error: { cause: toError(error51), kind: "network" } };
+    try {
+      await handle.close();
+      await fs3.rename(partPath, args.dest);
+    } catch (error51) {
+      await fs3.unlink(partPath).catch(() => {});
+      return { ok: false, error: { cause: toError(error51), kind: "network" } };
+    }
+    return { ok: true, data: undefined };
+  } finally {
+    clearTimeout(stallTimer);
   }
-  return { ok: true, data: undefined };
 }
 
 // src/shell/platform/downloadBundle.ts
@@ -172169,18 +172234,18 @@ var makeContractsV1 = (ids) => {
 var publicContractsV1 = makeContractsV1(defaultIdSchemas);
 
 // src/shell/platform/getIdentity.ts
-var timeoutMs2 = 1e4;
+var timeoutMs = 1e4;
 async function getIdentity(apiKey, deps) {
   const url2 = `${deps.baseUrl}/api/v0/identity`;
   let response;
   try {
     response = await deps.fetch(url2, {
       headers: { Authorization: `Bearer ${apiKey}` },
-      signal: AbortSignal.timeout(timeoutMs2)
+      signal: AbortSignal.timeout(timeoutMs)
     });
   } catch (error51) {
     if (isTimeoutError(error51)) {
-      return { ok: false, error: { kind: "timeout", timeoutMs: timeoutMs2 } };
+      return { ok: false, error: { kind: "timeout", timeoutMs } };
     }
     return {
       ok: false,
@@ -172199,7 +172264,7 @@ async function getIdentity(apiKey, deps) {
     json2 = await response.json();
   } catch (error51) {
     if (isTimeoutError(error51)) {
-      return { ok: false, error: { kind: "timeout", timeoutMs: timeoutMs2 } };
+      return { ok: false, error: { kind: "timeout", timeoutMs } };
     }
     json2 = undefined;
   }
@@ -172262,9 +172327,6 @@ async function listTeamStorageFiles(trpc, args, deps) {
   return { ok: true, value: files };
 }
 
-// src/shell/platform/teamStorageAssets.ts
-import { dirname as dirname3, join as join9 } from "node:path";
-
 // src/shell/platform/teamStorageAssetManifest.ts
 import { dirname as dirname2 } from "node:path";
 var assetManifestSchema = exports_external.object({
@@ -172279,10 +172341,10 @@ var assetManifestSchema = exports_external.object({
 function assetManifestPath(assetsAbs) {
   return `${assetsAbs}.manifest.json`;
 }
-async function readAssetManifest(assetsAbs, fs2) {
+async function readAssetManifest(assetsAbs, fs3) {
   let raw;
   try {
-    raw = await fs2.readFile(assetManifestPath(assetsAbs));
+    raw = await fs3.readFile(assetManifestPath(assetsAbs));
   } catch (err) {
     if (isNoEntError(err))
       return new Map;
@@ -172299,7 +172361,7 @@ async function readAssetManifest(assetsAbs, fs2) {
     return new Map;
   return new Map(result.data.files.map((file2) => [file2.path, file2]));
 }
-async function writeAssetManifest(assetsAbs, files, fs2) {
+async function writeAssetManifest(assetsAbs, files, fs3) {
   const manifest = {
     version: 1,
     files: files.map((file2) => ({
@@ -172310,8 +172372,8 @@ async function writeAssetManifest(assetsAbs, files, fs2) {
     }))
   };
   const path2 = assetManifestPath(assetsAbs);
-  await fs2.mkdir(dirname2(path2), { recursive: true });
-  await fs2.writeFile(path2, `${JSON.stringify(manifest, undefined, 2)}
+  await fs3.mkdir(dirname2(path2), { recursive: true });
+  await fs3.writeFile(path2, `${JSON.stringify(manifest, undefined, 2)}
 `);
 }
 function serializeDate(value) {
@@ -172344,19 +172406,19 @@ import { join as join7, sep as sep2 } from "node:path";
 function mintAssetSnapshotPath(assetsAbs, label) {
   return `${assetsAbs}.${label}-${randomBytes2(8).toString("hex")}`;
 }
-async function replaceAssetsDir(assetsAbs, tmpAssets, fs2) {
+async function replaceAssetsDir(assetsAbs, tmpAssets, fs3) {
   const oldAssets = mintAssetSnapshotPath(assetsAbs, "old");
   let movedOldAssets = false;
   try {
-    if (await fs2.pathExists(assetsAbs)) {
-      await fs2.rename(assetsAbs, oldAssets);
+    if (await fs3.pathExists(assetsAbs)) {
+      await fs3.rename(assetsAbs, oldAssets);
       movedOldAssets = true;
     }
-    await fs2.rename(tmpAssets, assetsAbs);
+    await fs3.rename(tmpAssets, assetsAbs);
   } catch (error51) {
     if (movedOldAssets) {
       try {
-        await fs2.rename(oldAssets, assetsAbs);
+        await fs3.rename(oldAssets, assetsAbs);
       } catch (rollbackError) {
         throw new Error(`Failed to replace team-storage assets and rollback also failed; previous assets may remain at ${oldAssets}. Replace error: ${errorMessage(error51)}. Rollback error: ${errorMessage(rollbackError)}`, { cause: rollbackError });
       }
@@ -172364,18 +172426,18 @@ async function replaceAssetsDir(assetsAbs, tmpAssets, fs2) {
     throw error51;
   }
   if (movedOldAssets) {
-    await cleanupAssetSnapshot(oldAssets, fs2);
+    await cleanupAssetSnapshot(oldAssets, fs3);
   }
 }
-async function cleanupAssetSnapshot(absPath, fs2) {
-  await fs2.rm(absPath, { recursive: true, force: true }).catch(() => {});
+async function cleanupAssetSnapshot(absPath, fs3) {
+  await fs3.rm(absPath, { recursive: true, force: true }).catch(() => {});
 }
-async function hasExactAssetSnapshot(assetsAbs, filePaths, fs2) {
+async function hasExactAssetSnapshot(assetsAbs, filePaths, fs3) {
   const expected = expectedEntries(filePaths);
-  if (!await fs2.pathExists(assetsAbs))
+  if (!await fs3.pathExists(assetsAbs))
     return expected.size === 0;
   const actual = new Set;
-  await collectEntries(assetsAbs, "", actual, fs2);
+  await collectEntries(assetsAbs, "", actual, fs3);
   return setsEqual(actual, expected);
 }
 function expectedEntries(filePaths) {
@@ -172389,13 +172451,13 @@ function expectedEntries(filePaths) {
   }
   return entries;
 }
-async function collectEntries(root, relDir, out, fs2) {
+async function collectEntries(root, relDir, out, fs3) {
   const current = relDir ? join7(root, relDir) : root;
-  for (const entry of await fs2.readdirWithTypes(current)) {
+  for (const entry of await fs3.readdirWithTypes(current)) {
     const relPath = relDir ? join7(relDir, entry.name) : entry.name;
     out.add(relPath);
     if (entry.isDirectory()) {
-      await collectEntries(root, relPath, out, fs2);
+      await collectEntries(root, relPath, out, fs3);
     }
   }
 }
@@ -172407,22 +172469,45 @@ function setsEqual(left, right) {
 
 // src/shell/platform/teamStorageAssetReuse.ts
 import { join as join8 } from "node:path";
-async function reusableAssetPaths(assetsAbs, safeFiles, manifest, fs2) {
+async function reusableAssetPaths(assetsAbs, safeFiles, manifest, fs3) {
   const reusable = new Set;
   for (const { file: file2, relativePath } of safeFiles) {
-    if (await canReuseAsset(assetsAbs, relativePath, file2, manifest, fs2)) {
+    if (await canReuseAsset(assetsAbs, relativePath, file2, manifest, fs3)) {
       reusable.add(relativePath);
     }
   }
   return reusable;
 }
-async function canReuseAsset(assetsAbs, relativePath, file2, manifest, fs2) {
+async function canReuseAsset(assetsAbs, relativePath, file2, manifest, fs3) {
   if (file2.etag === undefined)
     return false;
   const previous = manifest.get(relativePath);
   if (previous?.etag !== file2.etag)
     return false;
-  return fs2.pathExists(join8(assetsAbs, relativePath));
+  return fs3.pathExists(join8(assetsAbs, relativePath));
+}
+
+// src/shell/platform/writeAssetSnapshot.ts
+import { dirname as dirname3, join as join9 } from "node:path";
+async function writeAssetSnapshot(args) {
+  let downloadedCount = 0;
+  const total = args.safeFiles.filter(({ relativePath }) => !args.reusable.has(relativePath)).length;
+  await args.deps.fs.mkdir(args.tmpAssets, { recursive: true });
+  for (const { file: file2, relativePath } of args.safeFiles) {
+    const dest = join9(args.tmpAssets, relativePath);
+    await args.deps.fs.mkdir(dirname3(dest), { recursive: true });
+    if (args.reusable.has(relativePath)) {
+      await args.deps.fs.copyFile(join9(args.assetsAbs, relativePath), dest);
+      continue;
+    }
+    args.deps.onProgress?.({ current: downloadedCount + 1, total });
+    const result = await fetchSignedUrl({ url: file2.signedUrl, dest }, { fetch: args.deps.fetch, fs: args.deps.fs });
+    if (!result.ok) {
+      throw new Error(describeTeamStorageDownloadError(file2.path, result.error));
+    }
+    downloadedCount++;
+  }
+  return downloadedCount;
 }
 
 // src/shell/platform/teamStorageAssets.ts
@@ -172437,9 +172522,9 @@ async function downloadTeamStorageAssets(args, deps = { fetch: globalThis.fetch
   }
 }
 async function writeTeamStorageAssets(args, deps) {
-  const fs2 = deps.fs ?? makeDefaultFs();
+  const fs3 = deps.fs ?? makeDefaultFs();
   const tmpAssets = mintAssetSnapshotPath(args.assetsAbs, "pull");
-  const manifest = await readAssetManifest(args.assetsAbs, fs2);
+  const manifest = await readAssetManifest(args.assetsAbs, fs3);
   const safeFiles = [];
   for (const file2 of args.files) {
     const relativePath = safeAssetPath(file2.path);
@@ -172447,54 +172532,36 @@ async function writeTeamStorageAssets(args, deps) {
       safeFiles.push({ file: file2, relativePath });
   }
   const skippedCount = args.files.length - safeFiles.length;
-  const reusable = await reusableAssetPaths(args.assetsAbs, safeFiles, manifest, fs2);
+  const reusable = await reusableAssetPaths(args.assetsAbs, safeFiles, manifest, fs3);
   const reusedCount = reusable.size;
-  if (reusedCount === safeFiles.length && await hasExactAssetSnapshot(args.assetsAbs, safeFiles.map((file2) => file2.relativePath), fs2)) {
+  if (reusedCount === safeFiles.length && await hasExactAssetSnapshot(args.assetsAbs, safeFiles.map((file2) => file2.relativePath), fs3)) {
     return { downloadedCount: 0, reusedCount, skippedCount };
   }
   try {
     const downloadedCount = await writeAssetSnapshot({
       assetsAbs: args.assetsAbs,
-      deps: { fetch: deps.fetch, fs: fs2 },
+      deps: { fetch: deps.fetch, fs: fs3, onProgress: deps.onProgress },
       reusable,
       safeFiles,
       tmpAssets
     });
-    await replaceAssetsDir(args.assetsAbs, tmpAssets, fs2);
+    await replaceAssetsDir(args.assetsAbs, tmpAssets, fs3);
     await writeAssetManifest(args.assetsAbs, safeFiles.map(({ file: file2, relativePath }) => ({
       ...file2,
       path: relativePath
-    })), fs2);
+    })), fs3);
     return { downloadedCount, reusedCount, skippedCount };
   } catch (error51) {
-    await cleanupAssetSnapshot(tmpAssets, fs2);
+    await cleanupAssetSnapshot(tmpAssets, fs3);
     throw error51;
   }
 }
-async function writeAssetSnapshot(args) {
-  let downloadedCount = 0;
-  await args.deps.fs.mkdir(args.tmpAssets, { recursive: true });
-  for (const { file: file2, relativePath } of args.safeFiles) {
-    const dest = join9(args.tmpAssets, relativePath);
-    await args.deps.fs.mkdir(dirname3(dest), { recursive: true });
-    if (args.reusable.has(relativePath)) {
-      await args.deps.fs.copyFile(join9(args.assetsAbs, relativePath), dest);
-      continue;
-    }
-    const result = await fetchSignedUrl({ url: file2.signedUrl, dest }, { fetch: args.deps.fetch, fs: args.deps.fs });
-    if (!result.ok) {
-      throw new Error(describeTeamStorageDownloadError(file2.path, result.error));
-    }
-    downloadedCount++;
-  }
-  return downloadedCount;
-}
 
 // src/shell/platform/createPlatformClient.ts
 var requestBackoffMs2 = [500, 1500];
 function createPlatformClient(apiKey, deps) {
   const trpc = createTrpcClient(apiKey, deps);
-  const fs2 = deps.fs ?? makeDefaultFs();
+  const fs3 = deps.fs ?? makeDefaultFs();
   async function getFlowsBundleUrlImpl(envId) {
     const result = await requestWithRetry({
       call: () => trpc.mutation("gitwolf.getFlowsBundleUrl", { environmentId: envId }, flowsBundleResponseSchema),
@@ -172540,11 +172607,11 @@ function createPlatformClient(apiKey, deps) {
       }
       return listTeamStorageFiles(trpc, { teamId: identity.value.team.id }, deps);
     },
-    async syncTeamStorageAssets(assetsAbs) {
+    async syncTeamStorageAssets(assetsAbs, opts) {
       const files = await this.listTeamStorageFiles();
       if (!files.ok)
         return files;
-      return downloadTeamStorageAssets({ assetsAbs, files: files.value }, { fetch: deps.fetch, fs: fs2 });
+      return downloadTeamStorageAssets({ assetsAbs, files: files.value }, { fetch: deps.fetch, fs: fs3, onProgress: opts?.onProgress });
     },
     async downloadBundle(envId) {
       const urlResult = await getFlowsBundleUrlImpl(envId);
@@ -172552,7 +172619,7 @@ function createPlatformClient(apiKey, deps) {
         return urlResult;
       return downloadBundle(urlResult.value.signedUrl, {
         fetch: deps.fetch,
-        fs: fs2
+        fs: fs3
       });
     }
   };
@@ -174386,8 +174453,9 @@ function createAgentRenderers() {
       const results = [];
       const total = steps.length;
       for (const [i2, step] of steps.entries()) {
-        writeStderrLine(`[${String(i2 + 1)}/${String(total)}] ${step.message}`);
-        results.push(await step.task());
+        const label = (message) => `[${String(i2 + 1)}/${String(total)}] ${message}`;
+        writeStderrLine(label(step.message));
+        results.push(await step.task((message) => writeStderrLine(label(message))));
       }
       const { typed, doneMessage } = finalizeResults(results, done);
       writeStderrLine(doneMessage);
@@ -174424,9 +174492,13 @@ ${body}` : ""));
         let currentLabel2 = "";
         try {
           for (const [i2, step] of steps.entries()) {
-            currentLabel2 = `[${String(i2 + 1)}/${String(total)}] ${step.message}`;
+            const label = (message) => `[${String(i2 + 1)}/${String(total)}] ${message}`;
+            currentLabel2 = label(step.message);
             clack.log.step(currentLabel2);
-            results.push(await step.task());
+            results.push(await step.task((message) => {
+              currentLabel2 = label(message);
+              clack.log.step(currentLabel2);
+            }));
           }
           const { typed, doneMessage } = finalizeResults(results, done);
           clack.log.success(doneMessage);
@@ -174440,13 +174512,17 @@ ${body}` : ""));
       let currentLabel = "";
       try {
         for (const [i2, step] of steps.entries()) {
-          currentLabel = `[${String(i2 + 1)}/${String(total)}] ${step.message}`;
+          const label = (message) => `[${String(i2 + 1)}/${String(total)}] ${message}`;
+          currentLabel = label(step.message);
           if (i2 === 0) {
             s.start(currentLabel);
           } else {
             s.message(currentLabel);
           }
-          results.push(await step.task());
+          results.push(await step.task((message) => {
+            currentLabel = label(message);
+            s.message(currentLabel);
+          }));
         }
         const { typed, doneMessage } = finalizeResults(results, done);
         s.stop(doneMessage);
@@ -174491,7 +174567,7 @@ function createJsonRenderers() {
           step: i2 + 1,
           total
         });
-        results.push(await step.task());
+        results.push(await step.task(() => {}));
       }
       const { typed, doneMessage } = finalizeResults(results, done);
       writeJsonDiagnostic({ type: "success", message: doneMessage });
@@ -174578,12 +174654,12 @@ function createVerboseContext(outputMode, isVerbose) {
 
 // src/shell/npmRegistry.ts
 var registryUrl = "https://registry.npmjs.org";
-var timeoutMs3 = 3000;
+var timeoutMs2 = 3000;
 async function fetchLatestVersion(packageName, deps = {}) {
   const fetchFn = deps.fetchFn ?? globalThis.fetch;
   try {
     const response = await fetchFn(`${registryUrl}/${packageName}/latest`, {
-      signal: AbortSignal.timeout(timeoutMs3)
+      signal: AbortSignal.timeout(timeoutMs2)
     });
     if (!response.ok)
       return;
@@ -174666,7 +174742,7 @@ function startUpdateCheck(deps) {
 // package.json
 var package_default = {
   name: "@qawolf/cli",
-  version: "1.7.4",
+  version: "1.7.5",
   description: "Run and manage QA Wolf flows from the terminal, CI, or an AI agent",
   keywords: [
     "automation",
@@ -174781,7 +174857,7 @@ function buildBaseContext(command, signals) {
     ...verboseWrite ? { verboseWrite } : {}
   });
   const apiBaseUrl = resolveHostUrl(env2);
-  const fs2 = makeDefaultFs();
+  const fs3 = makeDefaultFs();
   const ui = createUI(outputMode, {
     clack,
     ...verboseTarget ? { verboseTarget } : {}
@@ -174790,7 +174866,7 @@ function buildBaseContext(command, signals) {
     env: env2,
     currentVersion: package_default.version,
     configDir: getConfigDir(),
-    fs: fs2,
+    fs: fs3,
     fetchLatestVersion: () => fetchLatestVersion(package_default.name),
     renderNotice: (body, title) => ui.note(body, title)
   });
@@ -174806,7 +174882,7 @@ function buildBaseContext(command, signals) {
       apiBaseUrl,
       signals,
       log: (scope) => loggingSystem.createLogger(scope),
-      fs: fs2
+      fs: fs3
     },
     apiBaseUrl,
     loggingSystem,
@@ -175291,12 +175367,12 @@ async function checkApiKey(deps) {
 
 // src/domains/doctor/checks/apiUrl.ts
 async function checkApiUrl(deps) {
-  const timeoutMs4 = deps.timeoutMs ?? 5000;
+  const timeoutMs3 = deps.timeoutMs ?? 5000;
   let response;
   try {
     response = await deps.fetch(deps.apiBaseUrl, {
       method: "HEAD",
-      signal: AbortSignal.timeout(timeoutMs4)
+      signal: AbortSignal.timeout(timeoutMs3)
     });
   } catch (error51) {
     return {
@@ -175610,10 +175686,10 @@ function renderResults(ui, results) {
 
 // src/domains/flows/ensureDeps.ts
 import { dirname as dirname4, join as join14 } from "node:path";
-function findEnvDir(flowPath, fs2) {
+function findEnvDir(flowPath, fs3) {
   let dir = dirname4(flowPath);
   while (true) {
-    if (fs2.existsSync(join14(dir, "package.json")))
+    if (fs3.existsSync(join14(dir, "package.json")))
       return dir;
     const parent = dirname4(dir);
     if (parent === dir)
@@ -175621,8 +175697,8 @@ function findEnvDir(flowPath, fs2) {
     dir = parent;
   }
 }
-function resolveUniqueEnvDir(files, fs2) {
-  const dirs = new Set(files.map((f2) => findEnvDir(f2, fs2)).filter((d) => d !== undefined));
+function resolveUniqueEnvDir(files, fs3) {
+  const dirs = new Set(files.map((f2) => findEnvDir(f2, fs3)).filter((d) => d !== undefined));
   if (dirs.size > 1) {
     const listed = [...dirs].map((d) => `  - ${d}`).join(`
 `);
@@ -175630,9 +175706,9 @@ function resolveUniqueEnvDir(files, fs2) {
   }
   return dirs.size === 1 ? [...dirs][0] : undefined;
 }
-function resolveProjectDirSafe(files, fs2) {
+function resolveProjectDirSafe(files, fs3) {
   try {
-    return resolveUniqueEnvDir(files, fs2);
+    return resolveUniqueEnvDir(files, fs3);
   } catch {
     return;
   }
@@ -175775,12 +175851,12 @@ function build$3(options) {
   return options.group ? groupFiles : empty;
 }
 var resolveSymlinksAsync = function(path2, state, callback$1) {
-  const { queue, fs: fs2, options: { suppressErrors } } = state;
+  const { queue, fs: fs3, options: { suppressErrors } } = state;
   queue.enqueue();
-  fs2.realpath(path2, (error51, resolvedPath) => {
+  fs3.realpath(path2, (error51, resolvedPath) => {
     if (error51)
       return queue.dequeue(suppressErrors ? null : error51, state);
-    fs2.stat(resolvedPath, (error$1, stat) => {
+    fs3.stat(resolvedPath, (error$1, stat) => {
       if (error$1)
         return queue.dequeue(suppressErrors ? null : error$1, state);
       if (stat.isDirectory() && isRecursive(path2, resolvedPath, state))
@@ -175791,11 +175867,11 @@ var resolveSymlinksAsync = function(path2, state, callback$1) {
   });
 };
 var resolveSymlinks = function(path2, state, callback$1) {
-  const { queue, fs: fs2, options: { suppressErrors } } = state;
+  const { queue, fs: fs3, options: { suppressErrors } } = state;
   queue.enqueue();
   try {
-    const resolvedPath = fs2.realpathSync(path2);
-    const stat = fs2.statSync(resolvedPath);
+    const resolvedPath = fs3.realpathSync(path2);
+    const stat = fs3.statSync(resolvedPath);
     if (stat.isDirectory() && isRecursive(path2, resolvedPath, state))
       return;
     callback$1(stat, resolvedPath);
@@ -175878,23 +175954,23 @@ var walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
   state.queue.enqueue();
   if (currentDepth < 0)
     return state.queue.dequeue(null, state);
-  const { fs: fs2 } = state;
+  const { fs: fs3 } = state;
   state.visited.push(crawlPath);
   state.counts.directories++;
-  fs2.readdir(crawlPath || ".", readdirOpts, (error51, entries = []) => {
+  fs3.readdir(crawlPath || ".", readdirOpts, (error51, entries = []) => {
     callback$1(entries, directoryPath, currentDepth);
     state.queue.dequeue(state.options.suppressErrors ? null : error51, state);
   });
 };
 var walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
-  const { fs: fs2 } = state;
+  const { fs: fs3 } = state;
   if (currentDepth < 0)
     return;
   state.visited.push(crawlPath);
   state.counts.directories++;
   let entries = [];
   try {
-    entries = fs2.readdirSync(crawlPath || ".", readdirOpts);
+    entries = fs3.readdirSync(crawlPath || ".", readdirOpts);
   } catch (e) {
     if (!state.options.suppressErrors)
       throw e;
@@ -176523,25 +176599,25 @@ function extractFlowMeta(source) {
 }
 
 // src/domains/flows/expand.ts
-function makePeekFlowMeta(fs2) {
+function makePeekFlowMeta(fs3) {
   return async (filePath) => {
-    const source = await fs2.readFile(filePath);
+    const source = await fs3.readFile(filePath);
     return extractFlowMeta(source);
   };
 }
-async function resolveGlobRoots(cwd, fs2) {
+async function resolveGlobRoots(cwd, fs3) {
   const qawolfPath = join15(cwd, ".qawolf");
   let envDirs = [];
   try {
-    const entries = await fs2.readdirWithTypes(qawolfPath);
+    const entries = await fs3.readdirWithTypes(qawolfPath);
     envDirs = entries.filter((e) => e.isDirectory()).map((e) => join15(qawolfPath, e.name));
   } catch {}
   return [cwd, ...envDirs];
 }
-async function expandPatterns(patterns, cwd, logger, fs2) {
+async function expandPatterns(patterns, cwd, logger, fs3) {
   logger?.debug(`expandPatterns: ${patterns.join(", ")}`);
   const effectivePatterns = patterns.length > 0 ? patterns : ["**/*.flow.{ts,js}"];
-  const roots = await resolveGlobRoots(cwd, fs2);
+  const roots = await resolveGlobRoots(cwd, fs3);
   const seen = new Set;
   for (const root of roots) {
     const matches = await glob(effectivePatterns, {
@@ -176604,40 +176680,40 @@ function runStagingRoot() {
 function managedEnvDir() {
   return join16(managedEnvBaseDir(), managedEnvHash());
 }
-async function scaffoldManagedEnv(dir, fs2) {
-  await fs2.mkdir(dir, { recursive: true });
+async function scaffoldManagedEnv(dir, fs3) {
+  await fs3.mkdir(dir, { recursive: true });
   const dependencies = Object.fromEntries(pinnedPackages.map(({ name, version: version2 }) => [name, version2]));
-  await fs2.writeFile(join16(dir, "package.json"), JSON.stringify({ name: "qawolf-runtime", private: true, dependencies }, undefined, 2));
-  await fs2.writeFile(join16(dir, ".npmrc"), `@qawolf:registry=https://registry.npmjs.org/
+  await fs3.writeFile(join16(dir, "package.json"), JSON.stringify({ name: "qawolf-runtime", private: true, dependencies }, undefined, 2));
+  await fs3.writeFile(join16(dir, ".npmrc"), `@qawolf:registry=https://registry.npmjs.org/
 `);
 }
 
 // src/domains/runtimeEnv/clearRuntimeEnv.ts
 var runtimeSentinel = "qawolf-runtime";
-async function clearRuntimeEnv(fs2) {
+async function clearRuntimeEnv(fs3) {
   const dir = managedEnvBaseDir();
-  const existed = await fs2.pathExists(dir);
+  const existed = await fs3.pathExists(dir);
   if (!existed)
     return { dir, existed };
-  if (!await isManagedRuntimeBase(dir, fs2)) {
+  if (!await isManagedRuntimeBase(dir, fs3)) {
     throw new Error(`Refusing to delete ${dir}: it does not look like a QA Wolf managed ` + `runtime directory (expected only ${runtimeSentinel} hash dirs). ` + `Check your QAWOLF_RUNTIME_DIR override.`);
   }
-  await fs2.rm(dir, { recursive: true, force: true });
+  await fs3.rm(dir, { recursive: true, force: true });
   return { dir, existed };
 }
-async function isManagedRuntimeBase(dir, fs2) {
-  const entries = await fs2.readdirWithTypes(dir);
+async function isManagedRuntimeBase(dir, fs3) {
+  const entries = await fs3.readdirWithTypes(dir);
   for (const entry of entries) {
     if (!entry.isDirectory())
       return false;
-    if (!await hasRuntimeSentinel(join17(dir, entry.name), fs2))
+    if (!await hasRuntimeSentinel(join17(dir, entry.name), fs3))
       return false;
   }
   return true;
 }
-async function hasRuntimeSentinel(hashDir, fs2) {
+async function hasRuntimeSentinel(hashDir, fs3) {
   try {
-    const pkg = JSON.parse(await fs2.readFile(join17(hashDir, "package.json")));
+    const pkg = JSON.parse(await fs3.readFile(join17(hashDir, "package.json")));
     return pkg.name === runtimeSentinel;
   } catch {
     return false;
@@ -176712,10 +176788,10 @@ function spawnNpmInstall(cwd, spawn2 = spawn) {
 
 // src/domains/runtimeEnv/resolvePinned.ts
 import { join as join18 } from "node:path";
-function readInstalledVersion(dir, pkgName, fs2) {
+function readInstalledVersion(dir, pkgName, fs3) {
   try {
     const pkgPath = join18(dir, "node_modules", ...pkgName.split("/"), "package.json");
-    const raw = JSON.parse(fs2.readFileSync(pkgPath));
+    const raw = JSON.parse(fs3.readFileSync(pkgPath));
     const { version: version2 } = raw;
     return typeof version2 === "string" ? version2 : undefined;
   } catch {
@@ -176736,16 +176812,16 @@ var shims = [
     candidates: appiumCliCandidates
   }
 ];
-function pinnedResolutionFailures(dir, fs2, platform) {
+function pinnedResolutionFailures(dir, fs3, platform) {
   const failures = [];
   for (const { name, version: version2 } of pinnedPackages) {
-    const installed = readInstalledVersion(dir, name, fs2);
+    const installed = readInstalledVersion(dir, name, fs3);
     if (installed !== version2) {
       failures.push({ kind: "package", name, pinned: version2, installed });
     }
   }
   for (const { name, display, candidates } of shims) {
-    if (!candidates(dir, platform).some((p2) => fs2.existsSync(p2))) {
+    if (!candidates(dir, platform).some((p2) => fs3.existsSync(p2))) {
       failures.push({ kind: "shim", name, display });
     }
   }
@@ -176757,8 +176833,8 @@ function describePinnedFailure(failure) {
   }
   return failure.installed === undefined ? `${failure.name} (missing, pinned ${failure.pinned})` : `${failure.name} ${failure.installed} (pinned ${failure.pinned})`;
 }
-function allPinnedResolved(dir, fs2, platform) {
-  return pinnedResolutionFailures(dir, fs2, platform).length === 0;
+function allPinnedResolved(dir, fs3, platform) {
+  return pinnedResolutionFailures(dir, fs3, platform).length === 0;
 }
 
 // src/domains/runtimeEnv/shimDeps.ts
@@ -176790,7 +176866,7 @@ function normalizeExports(exports) {
   }
   return;
 }
-function resolveFromEnvDir(envDir, specifier, preference = "esm", fs2 = makeDefaultFs()) {
+function resolveFromEnvDir(envDir, specifier, preference = "esm", fs3 = makeDefaultFs()) {
   const isScoped = specifier.startsWith("@");
   const parts = specifier.split("/");
   const pkgPartCount = isScoped ? 2 : 1;
@@ -176800,7 +176876,7 @@ function resolveFromEnvDir(envDir, specifier, preference = "esm", fs2 = makeDefa
   const pkgDir = join19(envDir, "node_modules", ...pkgName.split("/"));
   let pkg;
   try {
-    pkg = JSON.parse(fs2.readFileSync(join19(pkgDir, "package.json")));
+    pkg = JSON.parse(fs3.readFileSync(join19(pkgDir, "package.json")));
   } catch (err) {
     if (isNoEntError(err))
       throw new Error(`Package '${pkgName}' not found in ${join19(envDir, "node_modules")}`, { cause: err });
@@ -176816,9 +176892,9 @@ function resolveFromEnvDir(envDir, specifier, preference = "esm", fs2 = makeDefa
 }
 
 // src/domains/runtimeEnv/shimDeps.ts
-function readShimMarker(shimDir, fs2) {
+function readShimMarker(shimDir, fs3) {
   try {
-    const pkg = JSON.parse(fs2.readFileSync(join20(shimDir, "package.json")));
+    const pkg = JSON.parse(fs3.readFileSync(join20(shimDir, "package.json")));
     if (pkg._qawolf_format) {
       return {
         _qawolf_version: pkg._qawolf_version ?? "",
@@ -176833,42 +176909,42 @@ function resolveBunBuild(bunBuild) {
     return globalThis.Bun;
   return bunBuild === false ? undefined : { build: bunBuild };
 }
-async function removeStaleShims(flowsDir, flowsDeps, fs2) {
+async function removeStaleShims(flowsDir, flowsDeps, fs3) {
   const shimsDir = join20(flowsDir, "node_modules");
-  if (!fs2.existsSync(shimsDir))
+  if (!fs3.existsSync(shimsDir))
     return;
   for (const dep of flowsDeps) {
     const shimDepDir = join20(shimsDir, ...dep.split("/"));
-    if (readShimMarker(shimDepDir, fs2)) {
-      await fs2.rm(shimDepDir, { recursive: true, force: true });
+    if (readShimMarker(shimDepDir, fs3)) {
+      await fs3.rm(shimDepDir, { recursive: true, force: true });
     }
   }
 }
 async function buildDepShim(args) {
-  const { envDir, flowsDir, dep, fs: fs2, build: build2 } = args;
+  const { envDir, flowsDir, dep, fs: fs3, build: build2 } = args;
   const depParts = dep.split("/");
   const depDir = join20(envDir, "node_modules", ...depParts);
-  if (!fs2.existsSync(depDir))
+  if (!fs3.existsSync(depDir))
     return;
   let depVersion;
   try {
-    const pkg = JSON.parse(fs2.readFileSync(join20(depDir, "package.json")));
+    const pkg = JSON.parse(fs3.readFileSync(join20(depDir, "package.json")));
     depVersion = pkg.version ?? "unknown";
   } catch {
     depVersion = "unknown";
   }
   const shimDir = join20(flowsDir, "node_modules", ...depParts);
-  if (fs2.existsSync(shimDir)) {
-    const marker = readShimMarker(shimDir, fs2);
+  if (fs3.existsSync(shimDir)) {
+    const marker = readShimMarker(shimDir, fs3);
     if (!marker)
       return;
     if (marker._qawolf_version === depVersion && marker._qawolf_format === "bun-build-v1")
       return;
-    await fs2.rm(shimDir, { recursive: true, force: true });
+    await fs3.rm(shimDir, { recursive: true, force: true });
   }
   let entry;
   try {
-    entry = resolveFromEnvDir(envDir, dep, "cjs", fs2);
+    entry = resolveFromEnvDir(envDir, dep, "cjs", fs3);
   } catch {
     return;
   }
@@ -176883,32 +176959,32 @@ async function buildDepShim(args) {
     throw new Error(`bun.build failed to shim ${dep}: ${logs}`);
   }
   const shimCode = await output.text();
-  await fs2.mkdir(shimDir, { recursive: true });
-  await fs2.writeFile(join20(shimDir, "package.json"), JSON.stringify({
+  await fs3.mkdir(shimDir, { recursive: true });
+  await fs3.writeFile(join20(shimDir, "package.json"), JSON.stringify({
     name: dep,
     _qawolf_version: depVersion,
     _qawolf_format: "bun-build-v1"
   }));
-  await fs2.writeFile(join20(shimDir, "index.js"), shimCode);
+  await fs3.writeFile(join20(shimDir, "index.js"), shimCode);
 }
-async function shimFlowsDeps(envDir, fs2 = makeDefaultFs(), bunBuild) {
+async function shimFlowsDeps(envDir, fs3 = makeDefaultFs(), bunBuild) {
   const flowsDir = join20(envDir, "node_modules", "@qawolf", "flows");
-  if (!fs2.existsSync(flowsDir))
+  if (!fs3.existsSync(flowsDir))
     return;
   let flowsDeps;
   try {
-    const flowsPkg = JSON.parse(fs2.readFileSync(join20(flowsDir, "package.json")));
+    const flowsPkg = JSON.parse(fs3.readFileSync(join20(flowsDir, "package.json")));
     flowsDeps = Object.keys(flowsPkg.dependencies ?? {});
   } catch {
     return;
   }
   const bun = resolveBunBuild(bunBuild);
   if (!bun) {
-    await removeStaleShims(flowsDir, flowsDeps, fs2);
+    await removeStaleShims(flowsDir, flowsDeps, fs3);
     return;
   }
   for (const dep of flowsDeps) {
-    await buildDepShim({ envDir, flowsDir, dep, fs: fs2, build: bun.build });
+    await buildDepShim({ envDir, flowsDir, dep, fs: fs3, build: bun.build });
   }
 }
 
@@ -176941,15 +177017,15 @@ async function installPinned(targetDir, deps) {
 
 // src/domains/runtimeEnv/ensureRuntimeEnv.ts
 async function ensureRuntimeEnv(args, deps = {}) {
-  const fs2 = deps.fs ?? makeDefaultFs();
+  const fs3 = deps.fs ?? makeDefaultFs();
   const resolveManagedDir = deps.resolveManagedDir ?? managedEnvDir;
   const install = deps.install ?? ((t2) => installPinned(t2, {
-    fs: fs2,
+    fs: fs3,
     spawnInstall: defaultSpawnInstall,
     platform: args.platform
   }));
   if (args.overrideDir !== undefined) {
-    const failures = pinnedResolutionFailures(args.overrideDir, fs2, args.platform);
+    const failures = pinnedResolutionFailures(args.overrideDir, fs3, args.platform);
     if (failures.length === 0) {
       return {
         depsRoot: args.overrideDir,
@@ -176959,27 +177035,27 @@ async function ensureRuntimeEnv(args, deps = {}) {
     }
     throw new Error(runnerMessages.depsDirIncomplete(args.overrideDir, failures.map(describePinnedFailure)));
   }
-  if (args.projectDir !== undefined && allPinnedResolved(args.projectDir, fs2, args.platform)) {
+  if (args.projectDir !== undefined && allPinnedResolved(args.projectDir, fs3, args.platform)) {
     return { depsRoot: args.projectDir, source: "project", installed: false };
   }
   const managed = resolveManagedDir();
-  if (allPinnedResolved(managed, fs2, args.platform)) {
+  if (allPinnedResolved(managed, fs3, args.platform)) {
     return { depsRoot: managed, source: "managed", installed: false };
   }
   await install(managed);
-  if (!allPinnedResolved(managed, fs2, args.platform)) {
+  if (!allPinnedResolved(managed, fs3, args.platform)) {
     throw new Error(`Managed runtime is incomplete after install at ${managed}.`);
   }
   return { depsRoot: managed, source: "managed", installed: true };
 }
 // src/domains/runtimeEnv/resolveDepsRootIfPresent.ts
-function resolveDepsRootIfPresent(args, fs2 = makeDefaultFs()) {
-  if (args.overrideDir !== undefined && allPinnedResolved(args.overrideDir, fs2, args.platform))
+function resolveDepsRootIfPresent(args, fs3 = makeDefaultFs()) {
+  if (args.overrideDir !== undefined && allPinnedResolved(args.overrideDir, fs3, args.platform))
     return args.overrideDir;
-  if (args.projectDir !== undefined && allPinnedResolved(args.projectDir, fs2, args.platform))
+  if (args.projectDir !== undefined && allPinnedResolved(args.projectDir, fs3, args.platform))
     return args.projectDir;
   const managed = managedEnvDir();
-  if (allPinnedResolved(managed, fs2, args.platform))
+  if (allPinnedResolved(managed, fs3, args.platform))
     return managed;
   return;
 }
@@ -177001,16 +177077,16 @@ async function collectRequiredAvds(files, peekFlowMeta) {
   return [...seen];
 }
 async function handleDoctor(ctx, opts) {
-  const { fs: fs2 } = ctx;
+  const { fs: fs3 } = ctx;
   const cwd = process.cwd();
-  const flowFiles = await expandPatterns([], cwd, undefined, fs2);
-  const projectDir = resolveProjectDirSafe([...flowFiles], fs2);
+  const flowFiles = await expandPatterns([], cwd, undefined, fs3);
+  const projectDir = resolveProjectDirSafe([...flowFiles], fs3);
   const envDir = resolveDepsRootIfPresent({
     platform: process.platform,
     ...projectDir !== undefined ? { projectDir } : {}
-  }, fs2);
-  const resolved = await resolveApiKey(ctx.configDir, fs2);
-  const requiredAvds = await collectRequiredAvds(flowFiles, makePeekFlowMeta(fs2));
+  }, fs3);
+  const resolved = await resolveApiKey(ctx.configDir, fs3);
+  const requiredAvds = await collectRequiredAvds(flowFiles, makePeekFlowMeta(fs3));
   const runAndroidChecks = opts.all || requiredAvds.length > 0;
   const cliCheck = {
     name: "qawolf",
@@ -177114,11 +177190,11 @@ async function flowsList(ctx, pattern, deps) {
   ctx.ui.outro(flowsMessages.flowCount(items.length));
 }
 function handleFlowsList(ctx, pattern) {
-  const { fs: fs2 } = ctx;
+  const { fs: fs3 } = ctx;
   return flowsList(ctx, pattern, {
     cwd: process.cwd(),
-    expandPatterns: (patterns, cwd) => expandPatterns(patterns, cwd, undefined, fs2),
-    peekFlowMeta: makePeekFlowMeta(fs2)
+    expandPatterns: (patterns, cwd) => expandPatterns(patterns, cwd, undefined, fs3),
+    peekFlowMeta: makePeekFlowMeta(fs3)
   });
 }
 
@@ -177183,10 +177259,10 @@ var manifestSchema = exports_external.object({
   qawolfCommittedAt: exports_external.string().optional(),
   flows: exports_external.array(flowEntrySchema)
 });
-async function readManifest(envDir, fs2 = makeDefaultFs()) {
+async function readManifest(envDir, fs3 = makeDefaultFs()) {
   let raw;
   try {
-    raw = await fs2.readFile(join21(envDir, manifestFilename));
+    raw = await fs3.readFile(join21(envDir, manifestFilename));
   } catch (err) {
     if (isNoEntError(err))
       return "missing";
@@ -177212,15 +177288,15 @@ async function readManifest(envDir, fs2 = makeDefaultFs()) {
     flows: result.data.flows
   };
 }
-async function writeManifest(envDir, manifest, fs2 = makeDefaultFs()) {
+async function writeManifest(envDir, manifest, fs3 = makeDefaultFs()) {
   const body = JSON.stringify(manifest, undefined, 2);
-  await fs2.writeFile(join21(envDir, manifestFilename), `${body}
+  await fs3.writeFile(join21(envDir, manifestFilename), `${body}
 `);
 }
-function hashFile(absPath, fs2 = makeDefaultFs()) {
+function hashFile(absPath, fs3 = makeDefaultFs()) {
   return new Promise((resolve5, reject) => {
     const hash2 = createHash2("sha256");
-    const stream = fs2.createReadStream(absPath);
+    const stream = fs3.createReadStream(absPath);
     stream.on("data", (chunk) => hash2.update(chunk));
     stream.on("end", () => resolve5(hash2.digest("hex")));
     stream.on("error", reject);
@@ -177350,25 +177426,25 @@ async function checkSafety(args) {
 
 // src/domains/flows/pull/bundle.ts
 import { join as join22, relative as relative4 } from "node:path";
-async function flattenSingleWrapper(dir, fs2 = makeDefaultFs()) {
-  const entries = await fs2.readdir(dir);
+async function flattenSingleWrapper(dir, fs3 = makeDefaultFs()) {
+  const entries = await fs3.readdir(dir);
   if (entries.length !== 1)
     return;
   const innerName = entries[0];
   if (!innerName)
     return;
   const inner = join22(dir, innerName);
-  const innerStat = await fs2.stat(inner);
+  const innerStat = await fs3.stat(inner);
   if (!innerStat.isDirectory())
     return;
-  for (const e of await fs2.readdir(inner)) {
-    await fs2.rename(join22(inner, e), join22(dir, e));
+  for (const e of await fs3.readdir(inner)) {
+    await fs3.rename(join22(inner, e), join22(dir, e));
   }
-  const leftovers = await fs2.readdir(inner);
+  const leftovers = await fs3.readdir(inner);
   if (leftovers.length > 0) {
     throw new Error(`flattenSingleWrapper: ${leftovers.length} unexpected item(s) remain in wrapper dir`);
   }
-  await fs2.rm(inner, { recursive: true });
+  await fs3.rm(inner, { recursive: true });
   return innerName;
 }
 function extractQawolfCommitSha(wrapperName) {
@@ -177377,11 +177453,11 @@ function extractQawolfCommitSha(wrapperName) {
   return /-([0-9a-f]{40})$/i.exec(wrapperName)?.[1];
 }
 var flowExtensions = [".flow.ts", ".flow.js"];
-async function buildManifest(args, fs2 = makeDefaultFs()) {
-  const flowPaths = await walkForFlows(args.bundleDir, fs2);
+async function buildManifest(args, fs3 = makeDefaultFs()) {
+  const flowPaths = await walkForFlows(args.bundleDir, fs3);
   const flows = await Promise.all(flowPaths.map(async (rel) => ({
     path: rel,
-    contentHash: await hashFile(join22(args.bundleDir, rel), fs2)
+    contentHash: await hashFile(join22(args.bundleDir, rel), fs3)
   })));
   return {
     envId: args.envId,
@@ -177394,28 +177470,28 @@ async function buildManifest(args, fs2 = makeDefaultFs()) {
     flows
   };
 }
-async function walkForFlows(root, fs2) {
+async function walkForFlows(root, fs3) {
   const out = [];
-  await walk(root, root, out, fs2);
+  await walk(root, root, out, fs3);
   return out.sort();
 }
-async function walk(current, root, out, fs2) {
-  const entries = await fs2.readdirWithTypes(current);
+async function walk(current, root, out, fs3) {
+  const entries = await fs3.readdirWithTypes(current);
   for (const e of entries) {
     const abs = join22(current, e.name);
     if (e.isDirectory()) {
-      await walk(abs, root, out, fs2);
+      await walk(abs, root, out, fs3);
     } else if (e.isFile() && flowExtensions.some((ext) => e.name.endsWith(ext))) {
       out.push(relative4(root, abs));
     }
   }
 }
-async function sampleQawolfCommittedAt(bundleDir, fs2 = makeDefaultFs()) {
-  const flowPaths = await walkForFlows(bundleDir, fs2);
+async function sampleQawolfCommittedAt(bundleDir, fs3 = makeDefaultFs()) {
+  const flowPaths = await walkForFlows(bundleDir, fs3);
   const sample = flowPaths[0];
   if (!sample)
     return;
-  return (await fs2.stat(join22(bundleDir, sample))).mtime.toISOString();
+  return (await fs3.stat(join22(bundleDir, sample))).mtime.toISOString();
 }
 
 // src/domains/flows/pull/applyTeamStorageRewrite.ts
@@ -177452,26 +177528,26 @@ function isSourceFile(name) {
 function isFlowFile(name) {
   return flowExtensions2.some((ext) => name.endsWith(ext));
 }
-async function walk2(dir, out, fs2) {
-  const entries = await fs2.readdirWithTypes(dir);
+async function walk2(dir, out, fs3) {
+  const entries = await fs3.readdirWithTypes(dir);
   for (const e of entries) {
     const abs = join23(dir, e.name);
     if (e.isDirectory()) {
-      await walk2(abs, out, fs2);
+      await walk2(abs, out, fs3);
     } else if (e.isFile() && isSourceFile(e.name)) {
       out.push(abs);
     }
   }
 }
-async function applyTeamStorageRewrite(rootDir, fs2 = makeDefaultFs()) {
+async function applyTeamStorageRewrite(rootDir, fs3 = makeDefaultFs()) {
   const files = [];
-  await walk2(rootDir, files, fs2);
+  await walk2(rootDir, files, fs3);
   const results = await Promise.all(files.map(async (file2) => {
-    const source = await fs2.readFile(file2);
+    const source = await fs3.readFile(file2);
     const result = rewriteTeamStorage(source);
     const finalSource = result.rewrites > 0 ? result.source : source;
     if (result.rewrites > 0) {
-      await fs2.writeFile(file2, finalSource);
+      await fs3.writeFile(file2, finalSource);
     }
     if (isFlowFile(file2) && finalSource.includes("process.env.TEAM_STORAGE_DIR")) {
       return relative5(rootDir, file2);
@@ -177545,10 +177621,10 @@ function unquote(escaped) {
 }
 
 // src/domains/flows/pull/envVars.ts
-async function writeEnvFile(envDir, vars, fs2 = makeDefaultFs()) {
+async function writeEnvFile(envDir, vars, fs3 = makeDefaultFs()) {
   if (Object.keys(vars).length === 0)
     return;
-  await fs2.writeFile(join24(envDir, ".env"), serializeDotenv(vars), {
+  await fs3.writeFile(join24(envDir, ".env"), serializeDotenv(vars), {
     mode: 384
   });
 }
@@ -179585,7 +179661,7 @@ var hs = Symbol("jobDone");
 var li = Symbol("addFSEntry");
 var sr = Symbol("addTarEntry");
 var cs = Symbol("stat");
-var fs2 = Symbol("readdir");
+var fs3 = Symbol("readdir");
 var ci = Symbol("onreaddir");
 var fi = Symbol("pipe");
 var rr = Symbol("entry");
@@ -179680,7 +179756,7 @@ var wt = class extends A2 {
       }
     this[Ct]();
   }
-  [fs2](t2) {
+  [fs3](t2) {
     t2.pending = true, this[G] += 1, ui.readdir(t2.absolute, (e, i2) => {
       if (t2.pending = false, this[G] -= 1, e)
         return this.emit("error", e);
@@ -179730,7 +179806,7 @@ var wt = class extends A2 {
       if (t2.stat && !t2.ignore) {
         if (!this.noDirRecurse && t2.stat.isDirectory() && !t2.readdir) {
           let e = this.readdirCache.get(t2.absolute);
-          if (e ? this[ci](t2, e) : this[fs2](t2), !t2.readdir)
+          if (e ? this[ci](t2, e) : this[fs3](t2), !t2.readdir)
             return;
         }
         if (t2.entry = this[rr](t2), !t2.entry) {
@@ -179787,7 +179863,7 @@ var kt = class extends wt {
     let e = this.follow ? "statSync" : "lstatSync";
     this[ai](t2, ui[e](t2.absolute));
   }
-  [fs2](t2) {
+  [fs3](t2) {
     this[ci](t2, ui.readdirSync(t2.absolute));
   }
   [fi](t2) {
@@ -180748,16 +180824,16 @@ function checkEntrySize(args) {
 // src/domains/flows/pull/extract.ts
 var defaultMaxEntryBytes = 50 * 1024 * 1024;
 var defaultMaxTotalBytes = 500 * 1024 * 1024;
-async function extractTarGz(tgzPath, destDir, opts = {}, fs3 = makeDefaultFs()) {
+async function extractTarGz(tgzPath, destDir, opts = {}, fs4 = makeDefaultFs()) {
   const maxEntryBytes = opts.maxEntryBytes ?? defaultMaxEntryBytes;
   const maxTotalBytes = opts.maxTotalBytes ?? defaultMaxTotalBytes;
-  await fs3.mkdir(destDir, { recursive: true });
+  await fs4.mkdir(destDir, { recursive: true });
   const destResolved = resolve7(destDir);
   return new Promise((resolveOuter, rejectOuter) => {
     let total = 0;
     let aborted2 = false;
     const pending = [];
-    const rs2 = fs3.createReadStream(tgzPath);
+    const rs2 = fs4.createReadStream(tgzPath);
     const gz = createGunzip();
     const parser = new st({ strict: true });
     const abort = (err) => {
@@ -180781,7 +180857,7 @@ async function extractTarGz(tgzPath, destDir, opts = {}, fs3 = makeDefaultFs())
         maxTotalBytes,
         addTotal: (n2) => total += n2,
         getTotal: () => total,
-        fs: fs3
+        fs: fs4
       }).catch((err) => {
         abort(err instanceof Error ? err : new Error(String(err)));
       });
@@ -180846,7 +180922,7 @@ function mintTempPath(destAbs, kind, registry2) {
   registry2.minted.add(path3);
   return path3;
 }
-async function removeTempDir(absPath, registry2, fs3 = makeDefaultFs()) {
+async function removeTempDir(absPath, registry2, fs4 = makeDefaultFs()) {
   if (!absPath || !isAbsolute4(absPath)) {
     throw new Error(`removeTempDir refused: not an absolute path (${absPath})`);
   }
@@ -180856,24 +180932,24 @@ async function removeTempDir(absPath, registry2, fs3 = makeDefaultFs()) {
   if (!registry2.minted.has(absPath)) {
     throw new Error(`removeTempDir refused: not minted in this registry`);
   }
-  await fs3.rm(absPath, { recursive: true, force: true });
+  await fs4.rm(absPath, { recursive: true, force: true });
   registry2.minted.delete(absPath);
 }
 
 // src/domains/flows/pull/stage.ts
-async function stageBundle(args, fs3 = makeDefaultFs()) {
+async function stageBundle(args, fs4 = makeDefaultFs()) {
   const registry2 = createTempPathRegistry();
   const tmpDir = mintTempPath(args.destAbs, "pull", registry2);
   try {
-    await extractTarGz(args.tmpArchive, tmpDir, {}, fs3);
-    const wrapperName = await flattenSingleWrapper(tmpDir, fs3);
-    const qawolfCommittedAt = await sampleQawolfCommittedAt(tmpDir, fs3);
-    const { flowsWithTeamStorageRefs } = await applyTeamStorageRewrite(tmpDir, fs3);
+    await extractTarGz(args.tmpArchive, tmpDir, {}, fs4);
+    const wrapperName = await flattenSingleWrapper(tmpDir, fs4);
+    const qawolfCommittedAt = await sampleQawolfCommittedAt(tmpDir, fs4);
+    const { flowsWithTeamStorageRefs } = await applyTeamStorageRewrite(tmpDir, fs4);
     const effectiveEnvVars = {
       ...args.envVars,
       TEAM_STORAGE_DIR: args.assetsAbs
     };
-    await writeEnvFile(tmpDir, effectiveEnvVars, fs3);
+    await writeEnvFile(tmpDir, effectiveEnvVars, fs4);
     const manifest = await buildManifest({
       envId: args.envId,
       bundleDir: tmpDir,
@@ -180882,22 +180958,22 @@ async function stageBundle(args, fs3 = makeDefaultFs()) {
       envVarsFetchedAt: args.envVarsFetchedAt,
       wrapperName,
       qawolfCommittedAt
-    }, fs3);
-    await writeManifest(tmpDir, manifest, fs3);
+    }, fs4);
+    await writeManifest(tmpDir, manifest, fs4);
     let oldDir;
     try {
-      if (await fs3.pathExists(args.destAbs)) {
+      if (await fs4.pathExists(args.destAbs)) {
         oldDir = mintTempPath(args.destAbs, "old", registry2);
-        await fs3.rename(args.destAbs, oldDir);
+        await fs4.rename(args.destAbs, oldDir);
       }
-      await fs3.rename(tmpDir, args.destAbs);
+      await fs4.rename(tmpDir, args.destAbs);
     } catch (err) {
       if (oldDir)
-        await fs3.rename(oldDir, args.destAbs).catch(() => {});
+        await fs4.rename(oldDir, args.destAbs).catch(() => {});
       throw err;
     }
     if (oldDir)
-      await removeTempDir(oldDir, registry2, fs3).catch(() => {});
+      await removeTempDir(oldDir, registry2, fs4).catch(() => {});
     return {
       envDir: args.destAbs,
       flowCount: manifest.flows.length,
@@ -180905,7 +180981,7 @@ async function stageBundle(args, fs3 = makeDefaultFs()) {
       flowsWithTeamStorageRefs
     };
   } catch (err) {
-    await removeTempDir(tmpDir, registry2, fs3).catch(() => {});
+    await removeTempDir(tmpDir, registry2, fs4).catch(() => {});
     throw err;
   }
 }
@@ -180963,8 +181039,10 @@ async function handleFlowsPull(ctx, opts, deps) {
       },
       {
         message: flowsMessages.pull.downloadingTeamStorageAssets,
-        task: async () => {
-          const result2 = await ctx.platformClient.syncTeamStorageAssets(assetsAbs);
+        task: async (update) => {
+          const result2 = await ctx.platformClient.syncTeamStorageAssets(assetsAbs, {
+            onProgress: ({ current, total }) => update(flowsMessages.pull.downloadingTeamStorageAssetsProgress(current, total))
+          });
           if (!result2.ok)
             throw new Error(result2.error);
           return result2.value;
@@ -181689,16 +181767,16 @@ import { join as join26 } from "node:path";
 var flowSubpathImports = { "#playwright": "playwright" };
 var packageJsonSchema = exports_external.looseObject({ imports: exports_external.record(exports_external.string(), exports_external.unknown()).catch({}) }).catch({ imports: {} });
 async function writeExecSubpathImports(args) {
-  const { execDir, fs: fs3 } = args;
+  const { execDir, fs: fs4 } = args;
   const pkgPath = join26(execDir, "package.json");
-  const pkg = packageJsonSchema.parse(await readPackageJson(pkgPath, fs3));
+  const pkg = packageJsonSchema.parse(await readPackageJson(pkgPath, fs4));
   const merged = { ...pkg, imports: { ...pkg.imports, ...flowSubpathImports } };
-  await fs3.writeFile(pkgPath, JSON.stringify(merged, undefined, 2));
+  await fs4.writeFile(pkgPath, JSON.stringify(merged, undefined, 2));
 }
-async function readPackageJson(pkgPath, fs3) {
+async function readPackageJson(pkgPath, fs4) {
   let content;
   try {
-    content = await fs3.readFile(pkgPath);
+    content = await fs4.readFile(pkgPath);
   } catch (err) {
     if (isNoEntError(err))
       return {};
@@ -181726,27 +181804,27 @@ async function createDirSymlink(source, target) {
 
 // src/domains/runtimeEnv/linkPinnedPackages.ts
 async function linkPinnedPackages(args) {
-  const { depsRoot, nodeModulesDir, fs: fs3 } = args;
+  const { depsRoot, nodeModulesDir, fs: fs4 } = args;
   const managedModules = join27(depsRoot, "node_modules");
-  await fs3.mkdir(nodeModulesDir, { recursive: true });
+  await fs4.mkdir(nodeModulesDir, { recursive: true });
   for (const { name } of pinnedPackages) {
     const segments = name.split("/");
     const target = join27(nodeModulesDir, ...segments);
     if (segments.length > 1) {
-      await fs3.mkdir(dirname8(target), { recursive: true });
+      await fs4.mkdir(dirname8(target), { recursive: true });
     }
-    await fs3.rm(target, { recursive: true, force: true });
+    await fs4.rm(target, { recursive: true, force: true });
     await createDirSymlink(join27(managedModules, ...segments), target);
   }
 }
 
 // src/domains/runtimeEnv/innerHop.ts
 async function populateInnerHop(args) {
-  const { depsRoot, execDir, fs: fs3 } = args;
+  const { depsRoot, execDir, fs: fs4 } = args;
   await linkPinnedPackages({
     depsRoot,
     nodeModulesDir: join28(execDir, "node_modules"),
-    fs: fs3
+    fs: fs4
   });
 }
 
@@ -181755,12 +181833,12 @@ import { lstat } from "node:fs/promises";
 import { dirname as dirname9, join as join29 } from "node:path";
 var executorPackageNames = new Set(pinnedPackages.map((p3) => p3.name));
 async function populateOuterHop(args) {
-  const { projectDir, runDir, fs: fs3 } = args;
+  const { projectDir, runDir, fs: fs4 } = args;
   if (projectDir === undefined)
     return { mode: "none" };
-  const installableDeps = await readInstallableDeps(projectDir, fs3);
+  const installableDeps = await readInstallableDeps(projectDir, fs4);
   const depNames = Object.keys(installableDeps);
-  const { satisfying, rejected } = await findSatisfyingNodeModulesDir(projectDir, depNames, fs3);
+  const { satisfying, rejected } = await findSatisfyingNodeModulesDir(projectDir, depNames, fs4);
   if (satisfying !== undefined) {
     await createDirSymlink(satisfying, join29(runDir, "node_modules"));
     return { mode: "symlink", nodeModulesDir: satisfying };
@@ -181768,22 +181846,22 @@ async function populateOuterHop(args) {
   if (depNames.length === 0)
     return { mode: "none" };
   args.onInstallStart?.(depNames.length);
-  await installOuterDeps(runDir, installableDeps, fs3, args.install ?? spawnNpmInstall);
+  await installOuterDeps(runDir, installableDeps, fs4, args.install ?? spawnNpmInstall);
   await linkPinnedPackages({
     depsRoot: args.depsRoot,
     nodeModulesDir: join29(runDir, "node_modules"),
-    fs: fs3
+    fs: fs4
   });
   return { mode: "install", depCount: depNames.length, rejected };
 }
-async function findSatisfyingNodeModulesDir(startDir, depNames, fs3) {
+async function findSatisfyingNodeModulesDir(startDir, depNames, fs4) {
   const rejected = [];
   let dir = startDir;
   while (true) {
     const candidate = join29(dir, "node_modules");
     const stats = await lstatSafe(candidate);
     if (stats !== undefined && stats.isDirectory() && !stats.isSymbolicLink()) {
-      const missing = depNames.filter((name) => !fs3.existsSync(join29(candidate, name, "package.json")));
+      const missing = depNames.filter((name) => !fs4.existsSync(join29(candidate, name, "package.json")));
       if (missing.length === 0)
         return { satisfying: candidate, rejected };
       rejected.push({ dir: candidate, missing });
@@ -181801,10 +181879,10 @@ async function lstatSafe(path3) {
     return;
   }
 }
-async function readInstallableDeps(projectDir, fs3) {
+async function readInstallableDeps(projectDir, fs4) {
   let content;
   try {
-    content = await fs3.readFile(join29(projectDir, "package.json"));
+    content = await fs4.readFile(join29(projectDir, "package.json"));
   } catch {
     return {};
   }
@@ -181821,9 +181899,9 @@ async function readInstallableDeps(projectDir, fs3) {
     return {};
   return Object.fromEntries(Object.entries(rawDeps).filter(([name]) => !executorPackageNames.has(name)).filter((entry) => typeof entry[1] === "string"));
 }
-async function installOuterDeps(runDir, deps, fs3, install) {
-  await fs3.writeFile(join29(runDir, "package.json"), JSON.stringify({ name: "qawolf-run", private: true, dependencies: deps }, undefined, 2));
-  await fs3.writeFile(join29(runDir, ".npmrc"), `@qawolf:registry=https://registry.npmjs.org/
+async function installOuterDeps(runDir, deps, fs4, install) {
+  await fs4.writeFile(join29(runDir, "package.json"), JSON.stringify({ name: "qawolf-run", private: true, dependencies: deps }, undefined, 2));
+  await fs4.writeFile(join29(runDir, ".npmrc"), `@qawolf:registry=https://registry.npmjs.org/
 `);
   const result = await install(runDir);
   if (result.exitCode !== 0) {
@@ -181849,23 +181927,23 @@ async function copyDirExcluding(source, destination, excludedNames) {
 // src/domains/runtimeEnv/stageFlowFiles.ts
 var excludedDirs = new Set(["node_modules", ".git", ".qawolf"]);
 async function stageFlowFiles(args) {
-  const { files, projectDir, execDir, fs: fs3 } = args;
+  const { files, projectDir, execDir, fs: fs4 } = args;
   if (projectDir !== undefined) {
     await copyDirExcluding(projectDir, execDir, excludedDirs);
-    return Promise.all(files.map(async (f3) => remapPath(f3, projectDir, execDir) ?? stageOneFile(f3, execDir, fs3)));
+    return Promise.all(files.map(async (f3) => remapPath(f3, projectDir, execDir) ?? stageOneFile(f3, execDir, fs4)));
   }
   if (files.length > 1) {
-    return Promise.all(files.map((f3) => stageOneFile(f3, execDir, fs3)));
+    return Promise.all(files.map((f3) => stageOneFile(f3, execDir, fs4)));
   }
-  await Promise.all(files.map((f3) => fs3.copyFile(f3, join31(execDir, basename4(f3)))));
+  await Promise.all(files.map((f3) => fs4.copyFile(f3, join31(execDir, basename4(f3)))));
   return files.map((f3) => join31(execDir, basename4(f3)));
 }
-async function stageOneFile(file2, execDir, fs3) {
+async function stageOneFile(file2, execDir, fs4) {
   const dirHash = createHash3("sha256").update(dirname10(file2)).digest("hex").slice(0, 8);
   const subDir = join31(execDir, dirHash);
-  await fs3.mkdir(subDir, { recursive: true });
+  await fs4.mkdir(subDir, { recursive: true });
   const dest = join31(subDir, basename4(file2));
-  await fs3.copyFile(file2, dest);
+  await fs4.copyFile(file2, dest);
   return dest;
 }
 function remapPath(file2, projectDir, execDir) {
@@ -181880,30 +181958,30 @@ function remapPath(file2, projectDir, execDir) {
 // src/domains/runtimeEnv/prepareRunDir.ts
 async function prepareRunDir(args) {
   const { files, projectDir, depsRoot, runRoot } = args;
-  const fs3 = args.fs ?? makeDefaultFs();
+  const fs4 = args.fs ?? makeDefaultFs();
   const runId = buildRunId(projectDir, files);
   const runDir = join32(runRoot, runId);
-  await fs3.rm(runDir, { recursive: true, force: true });
-  await fs3.mkdir(runDir, { recursive: true });
+  await fs4.rm(runDir, { recursive: true, force: true });
+  await fs4.mkdir(runDir, { recursive: true });
   const execDir = join32(runDir, "exec");
-  await fs3.mkdir(execDir, { recursive: true });
-  await populateInnerHop({ depsRoot, execDir, fs: fs3 });
-  const stagedFiles = await stageFlowFiles({ files, projectDir, execDir, fs: fs3 });
+  await fs4.mkdir(execDir, { recursive: true });
+  await populateInnerHop({ depsRoot, execDir, fs: fs4 });
+  const stagedFiles = await stageFlowFiles({ files, projectDir, execDir, fs: fs4 });
   if (projectDir !== undefined) {
-    await writeExecSubpathImports({ execDir, fs: fs3 });
+    await writeExecSubpathImports({ execDir, fs: fs4 });
   }
   const outerHop = await populateOuterHop({
     projectDir,
     runDir,
     depsRoot,
-    fs: fs3,
+    fs: fs4,
     ...args.onInstallStart !== undefined ? { onInstallStart: args.onInstallStart } : {}
   });
   return {
     files: stagedFiles,
     runDir,
     outerHop,
-    cleanup: () => fs3.rm(runDir, { recursive: true, force: true })
+    cleanup: () => fs4.rm(runDir, { recursive: true, force: true })
   };
 }
 function buildRunId(projectDir, files) {
@@ -181950,13 +182028,13 @@ async function configureTestkit(cwd, deps) {
 
 // src/commands/resolveDepsRoot.ts
 function resolveDepsRoot(args) {
-  const fs3 = args.fs ?? makeDefaultFs();
-  const projectDir = resolveProjectDirSafe(args.files, fs3);
+  const fs4 = args.fs ?? makeDefaultFs();
+  const projectDir = resolveProjectDirSafe(args.files, fs4);
   return ensureRuntimeEnv({
     platform: args.platform,
     ...projectDir !== undefined ? { projectDir } : {},
     ...args.overrideDir !== undefined ? { overrideDir: args.overrideDir } : {}
-  }, { fs: fs3 });
+  }, { fs: fs4 });
 }
 
 // src/domains/emails/configureEmails.ts
@@ -181988,31 +182066,31 @@ import { join as join34 } from "node:path";
 function envFilePath(envDir) {
   return join34(envDir, ".env");
 }
-async function readEnv(envDir, fs3) {
+async function readEnv(envDir, fs4) {
   try {
-    return parseDotenv(await fs3.readFile(envFilePath(envDir)));
+    return parseDotenv(await fs4.readFile(envFilePath(envDir)));
   } catch (err) {
     if (isNoEntError(err))
       return {};
     throw err;
   }
 }
-async function writeEnv(envDir, fs3, vars) {
+async function writeEnv(envDir, fs4, vars) {
   const target = envFilePath(envDir);
   const tmp = `${target}.${process.pid}.tmp`;
-  await fs3.writeFile(tmp, serializeDotenv(vars), { mode: 384 });
-  await fs3.rename(tmp, target);
+  await fs4.writeFile(tmp, serializeDotenv(vars), { mode: 384 });
+  await fs4.rename(tmp, target);
 }
-function makeEnvVarDeps(envDir, fs3) {
+function makeEnvVarDeps(envDir, fs4) {
   return {
     setEnvironmentVariable: async (key, value) => {
-      const vars = await readEnv(envDir, fs3);
+      const vars = await readEnv(envDir, fs4);
       vars[key] = value;
-      await writeEnv(envDir, fs3, vars);
+      await writeEnv(envDir, fs4, vars);
       process.env[key] = value;
     },
     fetchLatestEnvironmentVariables: async () => {
-      const vars = await readEnv(envDir, fs3);
+      const vars = await readEnv(envDir, fs4);
       for (const [key, value] of Object.entries(vars)) {
         process.env[key] = value;
       }
@@ -182134,7 +182212,7 @@ var defaultSpawnAppium = (bin, args, platform, env2) => {
 var readyBanner = "Appium REST http interface listener started on";
 var defaultStartTimeoutMs = 30000;
 var bannerBufferMaxBytes = 1024;
-function waitForBanner(output, exitCode, timeoutMs4) {
+function waitForBanner(output, exitCode, timeoutMs3) {
   return new Promise((resolve10, reject) => {
     let done = false;
     function cleanup() {
@@ -182158,8 +182236,8 @@ function waitForBanner(output, exitCode, timeoutMs4) {
     };
     const timer = setTimeout(() => {
       cleanup();
-      reject(new Error(`Appium server did not start within ${timeoutMs4 / 1000}s`));
-    }, timeoutMs4);
+      reject(new Error(`Appium server did not start within ${timeoutMs3 / 1000}s`));
+    }, timeoutMs3);
     output.on("data", onData);
     const fail = (err) => {
       if (done)
@@ -182175,7 +182253,7 @@ async function createAppiumServer(envDir, signals, params) {
   const findFreePortFn = params?.deps?.findFreePort ?? findFreePort;
   const checkExists = params?.deps?.checkExists ?? existsSync2;
   const appiumHome = params?.options?.appiumHome ?? getAppiumHome();
-  const timeoutMs4 = params?.options?.startTimeoutMs ?? defaultStartTimeoutMs;
+  const timeoutMs3 = params?.options?.startTimeoutMs ?? defaultStartTimeoutMs;
   const platform = params?.options?.platform ?? process.platform;
   const candidates = appiumCliCandidates(envDir, platform);
   const bin = candidates.find(checkExists);
@@ -182192,7 +182270,7 @@ async function createAppiumServer(envDir, signals, params) {
     proc.kill();
   };
   const unregister = signals.register(stop);
-  await waitForBanner(proc.output, proc.exitCode, timeoutMs4).catch((err) => {
+  await waitForBanner(proc.output, proc.exitCode, timeoutMs3).catch((err) => {
     unregister();
     stop();
     throw err;
@@ -182243,13 +182321,13 @@ async function bootSequence(adb, serial, cancelled) {
     await new Promise((r2) => setTimeout(r2, pollIntervalMs));
   }
 }
-function waitForBoot(adb, serial, timeoutMs4) {
+function waitForBoot(adb, serial, timeoutMs3) {
   return new Promise((resolve10, reject) => {
     let done = false;
     const timer = setTimeout(() => {
       done = true;
-      reject(new Error(`Android emulator did not finish booting within ${timeoutMs4 / 1000}s`));
-    }, timeoutMs4);
+      reject(new Error(`Android emulator did not finish booting within ${timeoutMs3 / 1000}s`));
+    }, timeoutMs3);
     bootSequence(adb, serial, () => done).then(() => {
       if (!done) {
         done = true;
@@ -182269,7 +182347,7 @@ async function createAndroidEmulator(params) {
   const { avdName, port } = params;
   const spawnFn = params.deps?.spawn ?? defaultSpawnEmulator;
   const adbFn = params.deps?.adb ?? defaultAdb;
-  const timeoutMs4 = params.options?.bootTimeoutMs ?? defaultBootTimeoutMs;
+  const timeoutMs3 = params.options?.bootTimeoutMs ?? defaultBootTimeoutMs;
   const serial = `emulator-${port}`;
   const proc = spawnFn(emulatorBin(androidSdkHome(), process.platform), [
     "-avd",
@@ -182280,7 +182358,7 @@ async function createAndroidEmulator(params) {
     String(port)
   ]);
   try {
-    await waitForBoot(adbFn, serial, timeoutMs4);
+    await waitForBoot(adbFn, serial, timeoutMs3);
   } catch (err) {
     proc.stop();
     throw err;
@@ -184889,4 +184967,4 @@ createProgram({ signals }).parseAsync().catch(() => {
     process.exitCode = 1;
 }).finally(() => flushAndExit(typeof process.exitCode === "number" ? process.exitCode : 0));
 
-//# debugId=6CBE0567ED2CC02E64756E2164756E21
+//# debugId=6C7CEF86B6A2980364756E2164756E21