@playcademy/vite-plugin 0.0.1-beta.3 → 0.0.1-beta.6

package/dist/index.js

@@ -18,6 +18,76 @@ var __toESM = (mod, isNodeMode, target) => {
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// ../../node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports, module) => {
+  var p = process || {};
+  var argv = p.argv || [];
+  var env = p.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input) => {
+    let string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index) => {
+    let result = "", cursor = 0;
+    do {
+      result += string.substring(cursor, index) + replace;
+      cursor = index + close.length;
+      index = string.indexOf(close, cursor);
+    } while (~index);
+    return result + string.substring(cursor);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f("\x1B[0m", "\x1B[0m"),
+      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f("\x1B[3m", "\x1B[23m"),
+      underline: f("\x1B[4m", "\x1B[24m"),
+      inverse: f("\x1B[7m", "\x1B[27m"),
+      hidden: f("\x1B[8m", "\x1B[28m"),
+      strikethrough: f("\x1B[9m", "\x1B[29m"),
+      black: f("\x1B[30m", "\x1B[39m"),
+      red: f("\x1B[31m", "\x1B[39m"),
+      green: f("\x1B[32m", "\x1B[39m"),
+      yellow: f("\x1B[33m", "\x1B[39m"),
+      blue: f("\x1B[34m", "\x1B[39m"),
+      magenta: f("\x1B[35m", "\x1B[39m"),
+      cyan: f("\x1B[36m", "\x1B[39m"),
+      white: f("\x1B[37m", "\x1B[39m"),
+      gray: f("\x1B[90m", "\x1B[39m"),
+      bgBlack: f("\x1B[40m", "\x1B[49m"),
+      bgRed: f("\x1B[41m", "\x1B[49m"),
+      bgGreen: f("\x1B[42m", "\x1B[49m"),
+      bgYellow: f("\x1B[43m", "\x1B[49m"),
+      bgBlue: f("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f("\x1B[45m", "\x1B[49m"),
+      bgCyan: f("\x1B[46m", "\x1B[49m"),
+      bgWhite: f("\x1B[47m", "\x1B[49m"),
+      blackBright: f("\x1B[90m", "\x1B[39m"),
+      redBright: f("\x1B[91m", "\x1B[39m"),
+      greenBright: f("\x1B[92m", "\x1B[39m"),
+      yellowBright: f("\x1B[93m", "\x1B[39m"),
+      blueBright: f("\x1B[94m", "\x1B[39m"),
+      magentaBright: f("\x1B[95m", "\x1B[39m"),
+      cyanBright: f("\x1B[96m", "\x1B[39m"),
+      whiteBright: f("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
+
 // ../../node_modules/readdir-glob/node_modules/minimatch/lib/path.js
 var require_path = __commonJS((exports, module) => {
   var isWindows = typeof process === "object" && process && process.platform === "win32";
@@ -240,8 +310,8 @@ var require_minimatch = __commonJS((exports, module) => {
     return new Minimatch(pattern, options).match(p);
   };
   module.exports = minimatch;
-  var path = require_path();
-  minimatch.sep = path.sep;
+  var path2 = require_path();
+  minimatch.sep = path2.sep;
   var GLOBSTAR = Symbol("globstar **");
   minimatch.GLOBSTAR = GLOBSTAR;
   var expand = require_brace_expansion();
@@ -755,8 +825,8 @@ globstar while`, file, fr, pattern, pr, swallowee);
       if (f === "/" && partial)
         return true;
       const options = this.options;
-      if (path.sep !== "/") {
-        f = f.split(path.sep).join("/");
+      if (path2.sep !== "/") {
+        f = f.split(path2.sep).join("/");
       }
       f = f.split(slashSplit);
       this.debug(this.pattern, "split", f);
@@ -795,13 +865,13 @@ globstar while`, file, fr, pattern, pr, swallowee);
 // ../../node_modules/readdir-glob/index.js
 var require_readdir_glob = __commonJS((exports, module) => {
   module.exports = readdirGlob;
-  var fs = __require("fs");
+  var fs2 = __require("fs");
   var { EventEmitter } = __require("events");
   var { Minimatch } = require_minimatch();
   var { resolve } = __require("path");
   function readdir(dir, strict) {
     return new Promise((resolve2, reject) => {
-      fs.readdir(dir, { withFileTypes: true }, (err, files) => {
+      fs2.readdir(dir, { withFileTypes: true }, (err, files) => {
         if (err) {
           switch (err.code) {
             case "ENOTDIR":
@@ -830,7 +900,7 @@ var require_readdir_glob = __commonJS((exports, module) => {
   }
   function stat(file, followSymlinks) {
     return new Promise((resolve2, reject) => {
-      const statFunc = followSymlinks ? fs.stat : fs.lstat;
+      const statFunc = followSymlinks ? fs2.stat : fs2.lstat;
       statFunc(file, (err, stats) => {
         if (err) {
           switch (err.code) {
@@ -851,8 +921,8 @@ var require_readdir_glob = __commonJS((exports, module) => {
       });
     });
   }
-  async function* exploreWalkAsync(dir, path, followSymlinks, useStat, shouldSkip, strict) {
-    let files = await readdir(path + dir, strict);
+  async function* exploreWalkAsync(dir, path2, followSymlinks, useStat, shouldSkip, strict) {
+    let files = await readdir(path2 + dir, strict);
     for (const file of files) {
       let name = file.name;
       if (name === undefined) {
@@ -861,7 +931,7 @@ var require_readdir_glob = __commonJS((exports, module) => {
       }
       const filename = dir + "/" + name;
       const relative = filename.slice(1);
-      const absolute = path + "/" + relative;
+      const absolute = path2 + "/" + relative;
       let stats = null;
       if (useStat || followSymlinks) {
         stats = await stat(absolute, followSymlinks);
@@ -875,15 +945,15 @@ var require_readdir_glob = __commonJS((exports, module) => {
       if (stats.isDirectory()) {
         if (!shouldSkip(relative)) {
           yield { relative, absolute, stats };
-          yield* exploreWalkAsync(filename, path, followSymlinks, useStat, shouldSkip, false);
+          yield* exploreWalkAsync(filename, path2, followSymlinks, useStat, shouldSkip, false);
         }
       } else {
         yield { relative, absolute, stats };
       }
     }
   }
-  async function* explore(path, followSymlinks, useStat, shouldSkip) {
-    yield* exploreWalkAsync("", path, followSymlinks, useStat, shouldSkip, true);
+  async function* explore(path2, followSymlinks, useStat, shouldSkip) {
+    yield* exploreWalkAsync("", path2, followSymlinks, useStat, shouldSkip, true);
   }
   function readOptions(options) {
     return {
@@ -2954,54 +3024,54 @@ var require_polyfills = __commonJS((exports, module) => {
   }
   var chdir;
   module.exports = patch;
-  function patch(fs) {
+  function patch(fs2) {
     if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-      patchLchmod(fs);
-    }
-    if (!fs.lutimes) {
-      patchLutimes(fs);
-    }
-    fs.chown = chownFix(fs.chown);
-    fs.fchown = chownFix(fs.fchown);
-    fs.lchown = chownFix(fs.lchown);
-    fs.chmod = chmodFix(fs.chmod);
-    fs.fchmod = chmodFix(fs.fchmod);
-    fs.lchmod = chmodFix(fs.lchmod);
-    fs.chownSync = chownFixSync(fs.chownSync);
-    fs.fchownSync = chownFixSync(fs.fchownSync);
-    fs.lchownSync = chownFixSync(fs.lchownSync);
-    fs.chmodSync = chmodFixSync(fs.chmodSync);
-    fs.fchmodSync = chmodFixSync(fs.fchmodSync);
-    fs.lchmodSync = chmodFixSync(fs.lchmodSync);
-    fs.stat = statFix(fs.stat);
-    fs.fstat = statFix(fs.fstat);
-    fs.lstat = statFix(fs.lstat);
-    fs.statSync = statFixSync(fs.statSync);
-    fs.fstatSync = statFixSync(fs.fstatSync);
-    fs.lstatSync = statFixSync(fs.lstatSync);
-    if (fs.chmod && !fs.lchmod) {
-      fs.lchmod = function(path, mode, cb) {
+      patchLchmod(fs2);
+    }
+    if (!fs2.lutimes) {
+      patchLutimes(fs2);
+    }
+    fs2.chown = chownFix(fs2.chown);
+    fs2.fchown = chownFix(fs2.fchown);
+    fs2.lchown = chownFix(fs2.lchown);
+    fs2.chmod = chmodFix(fs2.chmod);
+    fs2.fchmod = chmodFix(fs2.fchmod);
+    fs2.lchmod = chmodFix(fs2.lchmod);
+    fs2.chownSync = chownFixSync(fs2.chownSync);
+    fs2.fchownSync = chownFixSync(fs2.fchownSync);
+    fs2.lchownSync = chownFixSync(fs2.lchownSync);
+    fs2.chmodSync = chmodFixSync(fs2.chmodSync);
+    fs2.fchmodSync = chmodFixSync(fs2.fchmodSync);
+    fs2.lchmodSync = chmodFixSync(fs2.lchmodSync);
+    fs2.stat = statFix(fs2.stat);
+    fs2.fstat = statFix(fs2.fstat);
+    fs2.lstat = statFix(fs2.lstat);
+    fs2.statSync = statFixSync(fs2.statSync);
+    fs2.fstatSync = statFixSync(fs2.fstatSync);
+    fs2.lstatSync = statFixSync(fs2.lstatSync);
+    if (fs2.chmod && !fs2.lchmod) {
+      fs2.lchmod = function(path2, mode, cb) {
         if (cb)
           process.nextTick(cb);
       };
-      fs.lchmodSync = function() {};
+      fs2.lchmodSync = function() {};
     }
-    if (fs.chown && !fs.lchown) {
-      fs.lchown = function(path, uid, gid, cb) {
+    if (fs2.chown && !fs2.lchown) {
+      fs2.lchown = function(path2, uid, gid, cb) {
         if (cb)
           process.nextTick(cb);
       };
-      fs.lchownSync = function() {};
+      fs2.lchownSync = function() {};
     }
     if (platform === "win32") {
-      fs.rename = typeof fs.rename !== "function" ? fs.rename : function(fs$rename) {
+      fs2.rename = typeof fs2.rename !== "function" ? fs2.rename : function(fs$rename) {
         function rename(from, to, cb) {
           var start = Date.now();
           var backoff = 0;
           fs$rename(from, to, function CB(er) {
             if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 60000) {
               setTimeout(function() {
-                fs.stat(to, function(stater, st) {
+                fs2.stat(to, function(stater, st) {
                   if (stater && stater.code === "ENOENT")
                     fs$rename(from, to, CB);
                   else
@@ -3019,9 +3089,9 @@ var require_polyfills = __commonJS((exports, module) => {
         if (Object.setPrototypeOf)
           Object.setPrototypeOf(rename, fs$rename);
         return rename;
-      }(fs.rename);
+      }(fs2.rename);
     }
-    fs.read = typeof fs.read !== "function" ? fs.read : function(fs$read) {
+    fs2.read = typeof fs2.read !== "function" ? fs2.read : function(fs$read) {
       function read(fd, buffer, offset, length, position, callback_) {
         var callback;
         if (callback_ && typeof callback_ === "function") {
@@ -3029,23 +3099,23 @@ var require_polyfills = __commonJS((exports, module) => {
           callback = function(er, _2, __) {
             if (er && er.code === "EAGAIN" && eagCounter < 10) {
               eagCounter++;
-              return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+              return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
             }
             callback_.apply(this, arguments);
           };
         }
-        return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+        return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
       }
       if (Object.setPrototypeOf)
         Object.setPrototypeOf(read, fs$read);
       return read;
-    }(fs.read);
-    fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : function(fs$readSync) {
+    }(fs2.read);
+    fs2.readSync = typeof fs2.readSync !== "function" ? fs2.readSync : function(fs$readSync) {
       return function(fd, buffer, offset, length, position) {
         var eagCounter = 0;
         while (true) {
           try {
-            return fs$readSync.call(fs, fd, buffer, offset, length, position);
+            return fs$readSync.call(fs2, fd, buffer, offset, length, position);
           } catch (er) {
             if (er.code === "EAGAIN" && eagCounter < 10) {
               eagCounter++;
@@ -3055,90 +3125,90 @@ var require_polyfills = __commonJS((exports, module) => {
           }
         }
       };
-    }(fs.readSync);
-    function patchLchmod(fs2) {
-      fs2.lchmod = function(path, mode, callback) {
-        fs2.open(path, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
+    }(fs2.readSync);
+    function patchLchmod(fs3) {
+      fs3.lchmod = function(path2, mode, callback) {
+        fs3.open(path2, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
           if (err) {
             if (callback)
               callback(err);
             return;
           }
-          fs2.fchmod(fd, mode, function(err2) {
-            fs2.close(fd, function(err22) {
+          fs3.fchmod(fd, mode, function(err2) {
+            fs3.close(fd, function(err22) {
               if (callback)
                 callback(err2 || err22);
             });
           });
         });
       };
-      fs2.lchmodSync = function(path, mode) {
-        var fd = fs2.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+      fs3.lchmodSync = function(path2, mode) {
+        var fd = fs3.openSync(path2, constants.O_WRONLY | constants.O_SYMLINK, mode);
         var threw = true;
         var ret;
         try {
-          ret = fs2.fchmodSync(fd, mode);
+          ret = fs3.fchmodSync(fd, mode);
           threw = false;
         } finally {
           if (threw) {
             try {
-              fs2.closeSync(fd);
+              fs3.closeSync(fd);
             } catch (er) {}
           } else {
-            fs2.closeSync(fd);
+            fs3.closeSync(fd);
           }
         }
         return ret;
       };
     }
-    function patchLutimes(fs2) {
-      if (constants.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
-        fs2.lutimes = function(path, at, mt, cb) {
-          fs2.open(path, constants.O_SYMLINK, function(er, fd) {
+    function patchLutimes(fs3) {
+      if (constants.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
+        fs3.lutimes = function(path2, at, mt, cb) {
+          fs3.open(path2, constants.O_SYMLINK, function(er, fd) {
             if (er) {
               if (cb)
                 cb(er);
               return;
             }
-            fs2.futimes(fd, at, mt, function(er2) {
-              fs2.close(fd, function(er22) {
+            fs3.futimes(fd, at, mt, function(er2) {
+              fs3.close(fd, function(er22) {
                 if (cb)
                   cb(er2 || er22);
               });
             });
           });
         };
-        fs2.lutimesSync = function(path, at, mt) {
-          var fd = fs2.openSync(path, constants.O_SYMLINK);
+        fs3.lutimesSync = function(path2, at, mt) {
+          var fd = fs3.openSync(path2, constants.O_SYMLINK);
           var ret;
           var threw = true;
           try {
-            ret = fs2.futimesSync(fd, at, mt);
+            ret = fs3.futimesSync(fd, at, mt);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs2.closeSync(fd);
+                fs3.closeSync(fd);
               } catch (er) {}
             } else {
-              fs2.closeSync(fd);
+              fs3.closeSync(fd);
             }
           }
           return ret;
         };
-      } else if (fs2.futimes) {
-        fs2.lutimes = function(_a, _b, _c, cb) {
+      } else if (fs3.futimes) {
+        fs3.lutimes = function(_a, _b, _c, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs2.lutimesSync = function() {};
+        fs3.lutimesSync = function() {};
       }
     }
     function chmodFix(orig) {
       if (!orig)
         return orig;
       return function(target, mode, cb) {
-        return orig.call(fs, target, mode, function(er) {
+        return orig.call(fs2, target, mode, function(er) {
           if (chownErOk(er))
             er = null;
           if (cb)
@@ -3151,7 +3221,7 @@ var require_polyfills = __commonJS((exports, module) => {
         return orig;
       return function(target, mode) {
         try {
-          return orig.call(fs, target, mode);
+          return orig.call(fs2, target, mode);
         } catch (er) {
           if (!chownErOk(er))
             throw er;
@@ -3162,7 +3232,7 @@ var require_polyfills = __commonJS((exports, module) => {
       if (!orig)
         return orig;
       return function(target, uid, gid, cb) {
-        return orig.call(fs, target, uid, gid, function(er) {
+        return orig.call(fs2, target, uid, gid, function(er) {
           if (chownErOk(er))
             er = null;
           if (cb)
@@ -3175,7 +3245,7 @@ var require_polyfills = __commonJS((exports, module) => {
         return orig;
       return function(target, uid, gid) {
         try {
-          return orig.call(fs, target, uid, gid);
+          return orig.call(fs2, target, uid, gid);
         } catch (er) {
           if (!chownErOk(er))
             throw er;
@@ -3200,14 +3270,14 @@ var require_polyfills = __commonJS((exports, module) => {
           if (cb)
             cb.apply(this, arguments);
         }
-        return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
+        return options ? orig.call(fs2, target, options, callback) : orig.call(fs2, target, callback);
       };
     }
     function statFixSync(orig) {
       if (!orig)
         return orig;
       return function(target, options) {
-        var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
+        var stats = options ? orig.call(fs2, target, options) : orig.call(fs2, target);
         if (stats) {
           if (stats.uid < 0)
             stats.uid += 4294967296;
@@ -3236,17 +3306,17 @@ var require_polyfills = __commonJS((exports, module) => {
 var require_legacy_streams = __commonJS((exports, module) => {
   var Stream = __require("stream").Stream;
   module.exports = legacy;
-  function legacy(fs) {
+  function legacy(fs2) {
     return {
       ReadStream,
       WriteStream
     };
-    function ReadStream(path, options) {
+    function ReadStream(path2, options) {
       if (!(this instanceof ReadStream))
-        return new ReadStream(path, options);
+        return new ReadStream(path2, options);
       Stream.call(this);
       var self2 = this;
-      this.path = path;
+      this.path = path2;
       this.fd = null;
       this.readable = true;
       this.paused = false;
@@ -3281,7 +3351,7 @@ var require_legacy_streams = __commonJS((exports, module) => {
         });
         return;
       }
-      fs.open(this.path, this.flags, this.mode, function(err, fd) {
+      fs2.open(this.path, this.flags, this.mode, function(err, fd) {
         if (err) {
           self2.emit("error", err);
           self2.readable = false;
@@ -3292,11 +3362,11 @@ var require_legacy_streams = __commonJS((exports, module) => {
         self2._read();
       });
     }
-    function WriteStream(path, options) {
+    function WriteStream(path2, options) {
       if (!(this instanceof WriteStream))
-        return new WriteStream(path, options);
+        return new WriteStream(path2, options);
       Stream.call(this);
-      this.path = path;
+      this.path = path2;
       this.fd = null;
       this.writable = true;
       this.flags = "w";
@@ -3321,7 +3391,7 @@ var require_legacy_streams = __commonJS((exports, module) => {
       this.busy = false;
       this._queue = [];
       if (this.fd === null) {
-        this._open = fs.open;
+        this._open = fs2.open;
         this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
         this.flush();
       }
@@ -3351,7 +3421,7 @@ var require_clone = __commonJS((exports, module) => {
 
 // ../../node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS((exports, module) => {
-  var fs = __require("fs");
+  var fs2 = __require("fs");
   var polyfills = require_polyfills();
   var legacy = require_legacy_streams();
   var clone = require_clone();
@@ -3383,12 +3453,12 @@ var require_graceful_fs = __commonJS((exports, module) => {
 GFS4: `);
       console.error(m);
     };
-  if (!fs[gracefulQueue]) {
+  if (!fs2[gracefulQueue]) {
     queue = global[gracefulQueue] || [];
-    publishQueue(fs, queue);
-    fs.close = function(fs$close) {
+    publishQueue(fs2, queue);
+    fs2.close = function(fs$close) {
       function close(fd, cb) {
-        return fs$close.call(fs, fd, function(err) {
+        return fs$close.call(fs2, fd, function(err) {
           if (!err) {
             resetQueue();
           }
@@ -3400,48 +3470,48 @@ GFS4: `);
         value: fs$close
       });
       return close;
-    }(fs.close);
-    fs.closeSync = function(fs$closeSync) {
+    }(fs2.close);
+    fs2.closeSync = function(fs$closeSync) {
       function closeSync(fd) {
-        fs$closeSync.apply(fs, arguments);
+        fs$closeSync.apply(fs2, arguments);
         resetQueue();
       }
       Object.defineProperty(closeSync, previousSymbol, {
         value: fs$closeSync
       });
       return closeSync;
-    }(fs.closeSync);
+    }(fs2.closeSync);
     if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
       process.on("exit", function() {
-        debug(fs[gracefulQueue]);
-        __require("assert").equal(fs[gracefulQueue].length, 0);
+        debug(fs2[gracefulQueue]);
+        __require("assert").equal(fs2[gracefulQueue].length, 0);
       });
     }
   }
   var queue;
   if (!global[gracefulQueue]) {
-    publishQueue(global, fs[gracefulQueue]);
-  }
-  module.exports = patch(clone(fs));
-  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
-    module.exports = patch(fs);
-    fs.__patched = true;
-  }
-  function patch(fs2) {
-    polyfills(fs2);
-    fs2.gracefulify = patch;
-    fs2.createReadStream = createReadStream;
-    fs2.createWriteStream = createWriteStream;
-    var fs$readFile = fs2.readFile;
-    fs2.readFile = readFile;
-    function readFile(path, options, cb) {
+    publishQueue(global, fs2[gracefulQueue]);
+  }
+  module.exports = patch(clone(fs2));
+  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs2.__patched) {
+    module.exports = patch(fs2);
+    fs2.__patched = true;
+  }
+  function patch(fs3) {
+    polyfills(fs3);
+    fs3.gracefulify = patch;
+    fs3.createReadStream = createReadStream;
+    fs3.createWriteStream = createWriteStream;
+    var fs$readFile = fs3.readFile;
+    fs3.readFile = readFile;
+    function readFile(path2, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
-      return go$readFile(path, options, cb);
-      function go$readFile(path2, options2, cb2, startTime) {
-        return fs$readFile(path2, options2, function(err) {
+      return go$readFile(path2, options, cb);
+      function go$readFile(path3, options2, cb2, startTime) {
+        return fs$readFile(path3, options2, function(err) {
           if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$readFile, [path2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            enqueue([go$readFile, [path3, options2, cb2], err, startTime || Date.now(), Date.now()]);
           else {
             if (typeof cb2 === "function")
               cb2.apply(this, arguments);
@@ -3449,16 +3519,16 @@ GFS4: `);
         });
       }
     }
-    var fs$writeFile = fs2.writeFile;
-    fs2.writeFile = writeFile;
-    function writeFile(path, data, options, cb) {
+    var fs$writeFile = fs3.writeFile;
+    fs3.writeFile = writeFile;
+    function writeFile(path2, data, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
-      return go$writeFile(path, data, options, cb);
-      function go$writeFile(path2, data2, options2, cb2, startTime) {
-        return fs$writeFile(path2, data2, options2, function(err) {
+      return go$writeFile(path2, data, options, cb);
+      function go$writeFile(path3, data2, options2, cb2, startTime) {
+        return fs$writeFile(path3, data2, options2, function(err) {
           if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$writeFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            enqueue([go$writeFile, [path3, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
           else {
             if (typeof cb2 === "function")
               cb2.apply(this, arguments);
@@ -3466,17 +3536,17 @@ GFS4: `);
         });
       }
     }
-    var fs$appendFile = fs2.appendFile;
+    var fs$appendFile = fs3.appendFile;
     if (fs$appendFile)
-      fs2.appendFile = appendFile;
-    function appendFile(path, data, options, cb) {
+      fs3.appendFile = appendFile;
+    function appendFile(path2, data, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
-      return go$appendFile(path, data, options, cb);
-      function go$appendFile(path2, data2, options2, cb2, startTime) {
-        return fs$appendFile(path2, data2, options2, function(err) {
+      return go$appendFile(path2, data, options, cb);
+      function go$appendFile(path3, data2, options2, cb2, startTime) {
+        return fs$appendFile(path3, data2, options2, function(err) {
           if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$appendFile, [path2, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            enqueue([go$appendFile, [path3, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
           else {
             if (typeof cb2 === "function")
               cb2.apply(this, arguments);
@@ -3484,9 +3554,9 @@ GFS4: `);
         });
       }
     }
-    var fs$copyFile = fs2.copyFile;
+    var fs$copyFile = fs3.copyFile;
     if (fs$copyFile)
-      fs2.copyFile = copyFile;
+      fs3.copyFile = copyFile;
     function copyFile(src, dest, flags, cb) {
       if (typeof flags === "function") {
         cb = flags;
@@ -3504,24 +3574,24 @@ GFS4: `);
         });
       }
     }
-    var fs$readdir = fs2.readdir;
-    fs2.readdir = readdir;
+    var fs$readdir = fs3.readdir;
+    fs3.readdir = readdir;
     var noReaddirOptionVersions = /^v[0-5]\./;
-    function readdir(path, options, cb) {
+    function readdir(path2, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
-      var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir(path2, options2, cb2, startTime) {
-        return fs$readdir(path2, fs$readdirCallback(path2, options2, cb2, startTime));
-      } : function go$readdir(path2, options2, cb2, startTime) {
-        return fs$readdir(path2, options2, fs$readdirCallback(path2, options2, cb2, startTime));
+      var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir(path3, options2, cb2, startTime) {
+        return fs$readdir(path3, fs$readdirCallback(path3, options2, cb2, startTime));
+      } : function go$readdir(path3, options2, cb2, startTime) {
+        return fs$readdir(path3, options2, fs$readdirCallback(path3, options2, cb2, startTime));
       };
-      return go$readdir(path, options, cb);
-      function fs$readdirCallback(path2, options2, cb2, startTime) {
+      return go$readdir(path2, options, cb);
+      function fs$readdirCallback(path3, options2, cb2, startTime) {
         return function(err, files) {
           if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
             enqueue([
               go$readdir,
-              [path2, options2, cb2],
+              [path3, options2, cb2],
               err,
               startTime || Date.now(),
               Date.now()
@@ -3536,21 +3606,21 @@ GFS4: `);
       }
     }
     if (process.version.substr(0, 4) === "v0.8") {
-      var legStreams = legacy(fs2);
+      var legStreams = legacy(fs3);
       ReadStream = legStreams.ReadStream;
       WriteStream = legStreams.WriteStream;
     }
-    var fs$ReadStream = fs2.ReadStream;
+    var fs$ReadStream = fs3.ReadStream;
     if (fs$ReadStream) {
       ReadStream.prototype = Object.create(fs$ReadStream.prototype);
       ReadStream.prototype.open = ReadStream$open;
     }
-    var fs$WriteStream = fs2.WriteStream;
+    var fs$WriteStream = fs3.WriteStream;
     if (fs$WriteStream) {
       WriteStream.prototype = Object.create(fs$WriteStream.prototype);
       WriteStream.prototype.open = WriteStream$open;
     }
-    Object.defineProperty(fs2, "ReadStream", {
+    Object.defineProperty(fs3, "ReadStream", {
       get: function() {
         return ReadStream;
       },
@@ -3560,7 +3630,7 @@ GFS4: `);
       enumerable: true,
       configurable: true
     });
-    Object.defineProperty(fs2, "WriteStream", {
+    Object.defineProperty(fs3, "WriteStream", {
       get: function() {
         return WriteStream;
       },
@@ -3571,7 +3641,7 @@ GFS4: `);
       configurable: true
     });
     var FileReadStream = ReadStream;
-    Object.defineProperty(fs2, "FileReadStream", {
+    Object.defineProperty(fs3, "FileReadStream", {
       get: function() {
         return FileReadStream;
       },
@@ -3582,7 +3652,7 @@ GFS4: `);
       configurable: true
     });
     var FileWriteStream = WriteStream;
-    Object.defineProperty(fs2, "FileWriteStream", {
+    Object.defineProperty(fs3, "FileWriteStream", {
       get: function() {
         return FileWriteStream;
       },
@@ -3592,7 +3662,7 @@ GFS4: `);
       enumerable: true,
       configurable: true
     });
-    function ReadStream(path, options) {
+    function ReadStream(path2, options) {
       if (this instanceof ReadStream)
         return fs$ReadStream.apply(this, arguments), this;
       else
@@ -3612,7 +3682,7 @@ GFS4: `);
         }
       });
     }
-    function WriteStream(path, options) {
+    function WriteStream(path2, options) {
       if (this instanceof WriteStream)
         return fs$WriteStream.apply(this, arguments), this;
       else
@@ -3630,22 +3700,22 @@ GFS4: `);
         }
       });
     }
-    function createReadStream(path, options) {
-      return new fs2.ReadStream(path, options);
+    function createReadStream(path2, options) {
+      return new fs3.ReadStream(path2, options);
     }
-    function createWriteStream(path, options) {
-      return new fs2.WriteStream(path, options);
+    function createWriteStream(path2, options) {
+      return new fs3.WriteStream(path2, options);
     }
-    var fs$open = fs2.open;
-    fs2.open = open;
-    function open(path, flags, mode, cb) {
+    var fs$open = fs3.open;
+    fs3.open = open;
+    function open(path2, flags, mode, cb) {
       if (typeof mode === "function")
         cb = mode, mode = null;
-      return go$open(path, flags, mode, cb);
-      function go$open(path2, flags2, mode2, cb2, startTime) {
-        return fs$open(path2, flags2, mode2, function(err, fd) {
+      return go$open(path2, flags, mode, cb);
+      function go$open(path3, flags2, mode2, cb2, startTime) {
+        return fs$open(path3, flags2, mode2, function(err, fd) {
           if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-            enqueue([go$open, [path2, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            enqueue([go$open, [path3, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
           else {
             if (typeof cb2 === "function")
               cb2.apply(this, arguments);
@@ -3653,20 +3723,20 @@ GFS4: `);
         });
       }
     }
-    return fs2;
+    return fs3;
   }
   function enqueue(elem) {
     debug("ENQUEUE", elem[0].name, elem[1]);
-    fs[gracefulQueue].push(elem);
+    fs2[gracefulQueue].push(elem);
     retry();
   }
   var retryTimer;
   function resetQueue() {
     var now = Date.now();
-    for (var i = 0;i < fs[gracefulQueue].length; ++i) {
-      if (fs[gracefulQueue][i].length > 2) {
-        fs[gracefulQueue][i][3] = now;
-        fs[gracefulQueue][i][4] = now;
+    for (var i = 0;i < fs2[gracefulQueue].length; ++i) {
+      if (fs2[gracefulQueue][i].length > 2) {
+        fs2[gracefulQueue][i][3] = now;
+        fs2[gracefulQueue][i][4] = now;
       }
     }
     retry();
@@ -3674,9 +3744,9 @@ GFS4: `);
   function retry() {
     clearTimeout(retryTimer);
     retryTimer = undefined;
-    if (fs[gracefulQueue].length === 0)
+    if (fs2[gracefulQueue].length === 0)
       return;
-    var elem = fs[gracefulQueue].shift();
+    var elem = fs2[gracefulQueue].shift();
     var fn = elem[0];
     var args = elem[1];
     var err = elem[2];
@@ -3698,7 +3768,7 @@ GFS4: `);
         debug("RETRY", fn.name, args);
         fn.apply(null, args.concat([startTime]));
       } else {
-        fs[gracefulQueue].push(elem);
+        fs2[gracefulQueue].push(elem);
       }
     }
     if (retryTimer === undefined) {
@@ -5827,24 +5897,24 @@ var require_normalize_path = __commonJS((exports, module) => {
    * Copyright (c) 2014-2018, Jon Schlinkert.
    * Released under the MIT License.
    */
-  module.exports = function(path, stripTrailing) {
-    if (typeof path !== "string") {
+  module.exports = function(path2, stripTrailing) {
+    if (typeof path2 !== "string") {
       throw new TypeError("expected path to be a string");
     }
-    if (path === "\\" || path === "/")
+    if (path2 === "\\" || path2 === "/")
       return "/";
-    var len = path.length;
+    var len = path2.length;
     if (len <= 1)
-      return path;
+      return path2;
     var prefix = "";
-    if (len > 4 && path[3] === "\\") {
-      var ch = path[2];
-      if ((ch === "?" || ch === ".") && path.slice(0, 2) === "\\\\") {
-        path = path.slice(2);
+    if (len > 4 && path2[3] === "\\") {
+      var ch = path2[2];
+      if ((ch === "?" || ch === ".") && path2.slice(0, 2) === "\\\\") {
+        path2 = path2.slice(2);
         prefix = "//";
       }
     }
-    var segs = path.split(/[/\\]+/);
+    var segs = path2.split(/[/\\]+/);
     if (stripTrailing !== false && segs[segs.length - 1] === "") {
       segs.pop();
     }
@@ -14151,11 +14221,11 @@ var require_commonjs = __commonJS((exports) => {
     return (f) => f.length === len && f !== "." && f !== "..";
   };
   var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-  var path = {
+  var path2 = {
     win32: { sep: "\\" },
     posix: { sep: "/" }
   };
-  exports.sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
+  exports.sep = defaultPlatform === "win32" ? path2.win32.sep : path2.posix.sep;
   exports.minimatch.sep = exports.sep;
   exports.GLOBSTAR = Symbol("globstar **");
   exports.minimatch.GLOBSTAR = exports.GLOBSTAR;
@@ -16827,12 +16897,12 @@ var require_commonjs4 = __commonJS((exports) => {
     childrenCache() {
       return this.#children;
     }
-    resolve(path) {
-      if (!path) {
+    resolve(path2) {
+      if (!path2) {
         return this;
       }
-      const rootPath = this.getRootString(path);
-      const dir = path.substring(rootPath.length);
+      const rootPath = this.getRootString(path2);
+      const dir = path2.substring(rootPath.length);
       const dirParts = dir.split(this.splitSep);
       const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
       return result;
@@ -17362,8 +17432,8 @@ var require_commonjs4 = __commonJS((exports) => {
     newChild(name, type = UNKNOWN, opts = {}) {
       return new PathWin32(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
     }
-    getRootString(path) {
-      return node_path_1.win32.parse(path).root;
+    getRootString(path2) {
+      return node_path_1.win32.parse(path2).root;
     }
     getRoot(rootPath) {
       rootPath = uncToDrive(rootPath.toUpperCase());
@@ -17390,8 +17460,8 @@ var require_commonjs4 = __commonJS((exports) => {
     constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
       super(name, type, root, roots, nocase, children, opts);
     }
-    getRootString(path) {
-      return path.startsWith("/") ? "/" : "";
+    getRootString(path2) {
+      return path2.startsWith("/") ? "/" : "";
     }
     getRoot(_rootPath) {
       return this.root;
@@ -17412,8 +17482,8 @@ var require_commonjs4 = __commonJS((exports) => {
     #children;
     nocase;
     #fs;
-    constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16 * 1024, fs = defaultFS } = {}) {
-      this.#fs = fsFromOption(fs);
+    constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16 * 1024, fs: fs2 = defaultFS } = {}) {
+      this.#fs = fsFromOption(fs2);
       if (cwd instanceof URL || cwd.startsWith("file://")) {
         cwd = (0, node_url_1.fileURLToPath)(cwd);
       }
@@ -17449,11 +17519,11 @@ var require_commonjs4 = __commonJS((exports) => {
       }
       this.cwd = prev;
     }
-    depth(path = this.cwd) {
-      if (typeof path === "string") {
-        path = this.cwd.resolve(path);
+    depth(path2 = this.cwd) {
+      if (typeof path2 === "string") {
+        path2 = this.cwd.resolve(path2);
       }
-      return path.depth();
+      return path2.depth();
     }
     childrenCache() {
       return this.#children;
@@ -17869,9 +17939,9 @@ var require_commonjs4 = __commonJS((exports) => {
       process2();
       return results;
     }
-    chdir(path = this.cwd) {
+    chdir(path2 = this.cwd) {
       const oldCwd = this.cwd;
-      this.cwd = typeof path === "string" ? this.cwd.resolve(path) : path;
+      this.cwd = typeof path2 === "string" ? this.cwd.resolve(path2) : path2;
       this.cwd[setAsCwd](oldCwd);
     }
   }
@@ -17890,8 +17960,8 @@ var require_commonjs4 = __commonJS((exports) => {
     parseRootPath(dir) {
       return node_path_1.win32.parse(dir).root.toUpperCase();
     }
-    newRoot(fs) {
-      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs });
+    newRoot(fs2) {
+      return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs2 });
     }
     isAbsolute(p) {
       return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
@@ -17909,8 +17979,8 @@ var require_commonjs4 = __commonJS((exports) => {
     parseRootPath(_dir) {
       return "/";
     }
-    newRoot(fs) {
-      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs });
+    newRoot(fs2) {
+      return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs: fs2 });
     }
     isAbsolute(p) {
       return p.startsWith("/");
@@ -18184,8 +18254,8 @@ var require_processor = __commonJS((exports) => {
       this.store.set(target, current === undefined ? n : n & current);
     }
     entries() {
-      return [...this.store.entries()].map(([path, n]) => [
-        path,
+      return [...this.store.entries()].map(([path2, n]) => [
+        path2,
         !!(n & 2),
         !!(n & 1)
       ]);
@@ -18398,9 +18468,9 @@ var require_walker = __commonJS((exports) => {
     signal;
     maxDepth;
     includeChildMatches;
-    constructor(patterns, path, opts) {
+    constructor(patterns, path2, opts) {
       this.patterns = patterns;
-      this.path = path;
+      this.path = path2;
       this.opts = opts;
       this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
       this.includeChildMatches = opts.includeChildMatches !== false;
@@ -18419,11 +18489,11 @@ var require_walker = __commonJS((exports) => {
         });
       }
     }
-    #ignored(path) {
-      return this.seen.has(path) || !!this.#ignore?.ignored?.(path);
+    #ignored(path2) {
+      return this.seen.has(path2) || !!this.#ignore?.ignored?.(path2);
     }
-    #childrenIgnored(path) {
-      return !!this.#ignore?.childrenIgnored?.(path);
+    #childrenIgnored(path2) {
+      return !!this.#ignore?.childrenIgnored?.(path2);
     }
     pause() {
       this.paused = true;
@@ -18637,8 +18707,8 @@ var require_walker = __commonJS((exports) => {
 
   class GlobWalker extends GlobUtil {
     matches = new Set;
-    constructor(patterns, path, opts) {
-      super(patterns, path, opts);
+    constructor(patterns, path2, opts) {
+      super(patterns, path2, opts);
     }
     matchEmit(e) {
       this.matches.add(e);
@@ -18677,8 +18747,8 @@ var require_walker = __commonJS((exports) => {
 
   class GlobStream extends GlobUtil {
     results;
-    constructor(patterns, path, opts) {
-      super(patterns, path, opts);
+    constructor(patterns, path2, opts) {
+      super(patterns, path2, opts);
       this.results = new minipass_1.Minipass({
         signal: this.signal,
         objectMode: true
@@ -18996,8 +19066,8 @@ var require_commonjs5 = __commonJS((exports) => {
 
 // ../../node_modules/archiver-utils/file.js
 var require_file = __commonJS((exports, module) => {
-  var fs = require_graceful_fs();
-  var path = __require("path");
+  var fs2 = require_graceful_fs();
+  var path2 = __require("path");
   var flatten = require_flatten();
   var difference = require_difference();
   var union = require_union();
@@ -19022,8 +19092,8 @@ var require_file = __commonJS((exports, module) => {
     return result;
   };
   file.exists = function() {
-    var filepath = path.join.apply(path, arguments);
-    return fs.existsSync(filepath);
+    var filepath = path2.join.apply(path2, arguments);
+    return fs2.existsSync(filepath);
   };
   file.expand = function(...args) {
     var options = isPlainObject(args[0]) ? args.shift() : {};
@@ -19036,12 +19106,12 @@ var require_file = __commonJS((exports, module) => {
     });
     if (options.filter) {
       matches = matches.filter(function(filepath) {
-        filepath = path.join(options.cwd || "", filepath);
+        filepath = path2.join(options.cwd || "", filepath);
         try {
           if (typeof options.filter === "function") {
             return options.filter(filepath);
           } else {
-            return fs.statSync(filepath)[options.filter]();
+            return fs2.statSync(filepath)[options.filter]();
           }
         } catch (e) {
           return false;
@@ -19053,7 +19123,7 @@ var require_file = __commonJS((exports, module) => {
   file.expandMapping = function(patterns, destBase, options) {
     options = Object.assign({
       rename: function(destBase2, destPath) {
-        return path.join(destBase2 || "", destPath);
+        return path2.join(destBase2 || "", destPath);
       }
     }, options);
     var files = [];
@@ -19061,14 +19131,14 @@ var require_file = __commonJS((exports, module) => {
     file.expand(options, patterns).forEach(function(src) {
       var destPath = src;
       if (options.flatten) {
-        destPath = path.basename(destPath);
+        destPath = path2.basename(destPath);
       }
       if (options.ext) {
         destPath = destPath.replace(/(\.[^\/]*)?$/, options.ext);
       }
       var dest = options.rename(destBase, destPath, options);
       if (options.cwd) {
-        src = path.join(options.cwd, src);
+        src = path2.join(options.cwd, src);
       }
       dest = dest.replace(pathSeparatorRe, "/");
       src = src.replace(pathSeparatorRe, "/");
@@ -19147,8 +19217,8 @@ var require_file = __commonJS((exports, module) => {
 
 // ../../node_modules/archiver-utils/index.js
 var require_archiver_utils = __commonJS((exports, module) => {
-  var fs = require_graceful_fs();
-  var path = __require("path");
+  var fs2 = require_graceful_fs();
+  var path2 = __require("path");
   var isStream = require_is_stream();
   var lazystream = require_lazystream();
   var normalizePath = require_normalize_path();
@@ -19196,7 +19266,7 @@ var require_archiver_utils = __commonJS((exports, module) => {
   };
   utils.lazyReadStream = function(filepath) {
     return new lazystream.Readable(function() {
-      return fs.createReadStream(filepath);
+      return fs2.createReadStream(filepath);
     });
   };
   utils.normalizeInputSource = function(source) {
@@ -19224,7 +19294,7 @@ var require_archiver_utils = __commonJS((exports, module) => {
       callback = base;
       base = dirpath;
     }
-    fs.readdir(dirpath, function(err, list) {
+    fs2.readdir(dirpath, function(err, list) {
       var i = 0;
       var file;
       var filepath;
@@ -19236,11 +19306,11 @@ var require_archiver_utils = __commonJS((exports, module) => {
         if (!file) {
           return callback(null, results);
         }
-        filepath = path.join(dirpath, file);
-        fs.stat(filepath, function(err2, stats) {
+        filepath = path2.join(dirpath, file);
+        fs2.stat(filepath, function(err2, stats) {
           results.push({
             path: filepath,
-            relative: path.relative(base, filepath).replace(/\\/g, "/"),
+            relative: path2.relative(base, filepath).replace(/\\/g, "/"),
             stats
           });
           if (stats && stats.isDirectory()) {
@@ -24961,10 +25031,10 @@ var require_ours2 = __commonJS((exports, module) => {
 
 // ../../node_modules/archiver/lib/core.js
 var require_core = __commonJS((exports, module) => {
-  var fs = __require("fs");
+  var fs2 = __require("fs");
   var glob = require_readdir_glob();
   var async = require_async();
-  var path = __require("path");
+  var path2 = __require("path");
   var util = require_archiver_utils();
   var inherits = __require("util").inherits;
   var ArchiverError = require_error();
@@ -25025,7 +25095,7 @@ var require_core = __commonJS((exports, module) => {
     data.sourcePath = filepath;
     task.data = data;
     this._entriesCount++;
-    if (data.stats && data.stats instanceof fs.Stats) {
+    if (data.stats && data.stats instanceof fs2.Stats) {
       task = this._updateQueueTaskWithStats(task, data.stats);
       if (task) {
         if (data.stats.size) {
@@ -25196,7 +25266,7 @@ var require_core = __commonJS((exports, module) => {
       callback();
       return;
     }
-    fs.lstat(task.filepath, function(err, stats) {
+    fs2.lstat(task.filepath, function(err, stats) {
       if (this._state.aborted) {
         setImmediate(callback);
         return;
@@ -25239,10 +25309,10 @@ var require_core = __commonJS((exports, module) => {
       task.data.sourceType = "buffer";
       task.source = Buffer.concat([]);
     } else if (stats.isSymbolicLink() && this._moduleSupports("symlink")) {
-      var linkPath = fs.readlinkSync(task.filepath);
-      var dirName = path.dirname(task.filepath);
+      var linkPath = fs2.readlinkSync(task.filepath);
+      var dirName = path2.dirname(task.filepath);
       task.data.type = "symlink";
-      task.data.linkname = path.relative(dirName, path.resolve(dirName, linkPath));
+      task.data.linkname = path2.relative(dirName, path2.resolve(dirName, linkPath));
       task.data.sourceType = "buffer";
       task.source = Buffer.concat([]);
     } else {
@@ -40818,83 +40888,43 @@ var require_archiver = __commonJS((exports, module) => {
   module.exports = vending;
 });
 
-// ../../node_modules/picocolors/picocolors.js
-var require_picocolors = __commonJS((exports, module) => {
-  var p = process || {};
-  var argv = p.argv || [];
-  var env = p.env || {};
-  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-  var formatter = (open, close, replace = open) => (input) => {
-    let string = "" + input, index = string.indexOf(close, open.length);
-    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-  };
-  var replaceClose = (string, close, replace, index) => {
-    let result = "", cursor = 0;
-    do {
-      result += string.substring(cursor, index) + replace;
-      cursor = index + close.length;
-      index = string.indexOf(close, cursor);
-    } while (~index);
-    return result + string.substring(cursor);
-  };
-  var createColors = (enabled = isColorSupported) => {
-    let f = enabled ? formatter : () => String;
-    return {
-      isColorSupported: enabled,
-      reset: f("\x1B[0m", "\x1B[0m"),
-      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-      italic: f("\x1B[3m", "\x1B[23m"),
-      underline: f("\x1B[4m", "\x1B[24m"),
-      inverse: f("\x1B[7m", "\x1B[27m"),
-      hidden: f("\x1B[8m", "\x1B[28m"),
-      strikethrough: f("\x1B[9m", "\x1B[29m"),
-      black: f("\x1B[30m", "\x1B[39m"),
-      red: f("\x1B[31m", "\x1B[39m"),
-      green: f("\x1B[32m", "\x1B[39m"),
-      yellow: f("\x1B[33m", "\x1B[39m"),
-      blue: f("\x1B[34m", "\x1B[39m"),
-      magenta: f("\x1B[35m", "\x1B[39m"),
-      cyan: f("\x1B[36m", "\x1B[39m"),
-      white: f("\x1B[37m", "\x1B[39m"),
-      gray: f("\x1B[90m", "\x1B[39m"),
-      bgBlack: f("\x1B[40m", "\x1B[49m"),
-      bgRed: f("\x1B[41m", "\x1B[49m"),
-      bgGreen: f("\x1B[42m", "\x1B[49m"),
-      bgYellow: f("\x1B[43m", "\x1B[49m"),
-      bgBlue: f("\x1B[44m", "\x1B[49m"),
-      bgMagenta: f("\x1B[45m", "\x1B[49m"),
-      bgCyan: f("\x1B[46m", "\x1B[49m"),
-      bgWhite: f("\x1B[47m", "\x1B[49m"),
-      blackBright: f("\x1B[90m", "\x1B[39m"),
-      redBright: f("\x1B[91m", "\x1B[39m"),
-      greenBright: f("\x1B[92m", "\x1B[39m"),
-      yellowBright: f("\x1B[93m", "\x1B[39m"),
-      blueBright: f("\x1B[94m", "\x1B[39m"),
-      magentaBright: f("\x1B[95m", "\x1B[39m"),
-      cyanBright: f("\x1B[96m", "\x1B[39m"),
-      whiteBright: f("\x1B[97m", "\x1B[39m"),
-      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
-      bgRedBright: f("\x1B[101m", "\x1B[49m"),
-      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
-      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
-      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
-      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
-      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
-      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
-    };
-  };
-  module.exports = createColors();
-  module.exports.createColors = createColors;
-});
-
 // src/index.ts
-var import_archiver = __toESM(require_archiver(), 1);
+import path3 from "node:path";
+
+// src/lib/sandbox.ts
 var import_picocolors = __toESM(require_picocolors(), 1);
+import { startServer, version as sandboxVersion } from "@playcademy/sandbox";
+
+// src/utils.ts
 import path from "node:path";
-import fs from "node:fs/promises";
-import { createWriteStream } from "node:fs";
-var LOG_LINE_TOTAL_WIDTH = 60;
+import fs from "node:fs";
+function extractProjectInfo(viteConfig) {
+  const projectRoot = viteConfig.root;
+  const directoryName = path.basename(projectRoot);
+  let packageJson = {};
+  try {
+    const packageJsonPath = path.join(projectRoot, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJsonContent = fs.readFileSync(packageJsonPath, "utf-8");
+      packageJson = JSON.parse(packageJsonContent);
+    }
+  } catch {}
+  const name = typeof packageJson.name === "string" ? packageJson.name : "";
+  let slug = name;
+  if (slug.includes("/")) {
+    slug = slug.split("/")[1] || slug;
+  }
+  if (!slug) {
+    slug = directoryName;
+  }
+  const displayName = slug.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  return {
+    slug,
+    displayName,
+    version: (typeof packageJson.version === "string" ? packageJson.version : null) || "dev",
+    description: typeof packageJson.description === "string" ? packageJson.description : undefined
+  };
+}
 function formatNumberWithCommas(numStr) {
   if (!numStr)
     return numStr;
@@ -40904,40 +40934,349 @@ function formatNumberWithCommas(numStr) {
   parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
   return parts.join(".");
 }
+async function findAvailablePort(startPort = 4321) {
+  const { createServer } = await import("node:net");
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.listen(startPort, () => {
+      const address = server.address();
+      const port = address && typeof address === "object" ? address.port : startPort;
+      server.close(() => resolve(port));
+    });
+    server.on("error", () => {
+      findAvailablePort(startPort + 1).then(resolve).catch(reject);
+    });
+  });
+}
+
+// src/lib/sandbox.ts
+function printSandboxInfo(viteConfig, availablePort, projectInfo) {
+  viteConfig.logger.info("");
+  viteConfig.logger.info(`  ${import_picocolors.default.green(import_picocolors.default.bold("PLAYCADEMY"))} ${import_picocolors.default.green(`v${sandboxVersion}`)}`);
+  viteConfig.logger.info("");
+  viteConfig.logger.info(`  ${import_picocolors.default.green("➜")}  ${import_picocolors.default.bold("Game:")}    ${import_picocolors.default.cyan(projectInfo.slug)}`);
+  viteConfig.logger.info(`  ${import_picocolors.default.green("➜")}  ${import_picocolors.default.bold("Sandbox:")} ${import_picocolors.default.cyan(`http://localhost:${import_picocolors.default.bold(availablePort.toString())}/api`)}`);
+  viteConfig.logger.info("");
+}
+async function startSandbox(viteConfig, autoStart = true, verbose = false) {
+  if (!autoStart || viteConfig.command !== "serve") {
+    return {
+      url: "http://localhost:4321/api",
+      project: null,
+      cleanup: () => {}
+    };
+  }
+  try {
+    const availablePort = await findAvailablePort(4321);
+    const sandboxUrl = `http://localhost:${availablePort}/api`;
+    const projectInfo = extractProjectInfo(viteConfig);
+    const server = await startServer({
+      port: availablePort,
+      verbose,
+      seed: true,
+      project: projectInfo
+    });
+    setTimeout(() => {
+      printSandboxInfo(viteConfig, availablePort, projectInfo);
+    }, 100);
+    return {
+      url: sandboxUrl,
+      project: projectInfo,
+      cleanup: () => {
+        if (server && typeof server.close === "function") {
+          server.close();
+          viteConfig.logger.info(import_picocolors.default.yellow("[Playcademy] Sandbox server stopped"));
+        }
+      }
+    };
+  } catch (error) {
+    viteConfig.logger.error(import_picocolors.default.red(`[Playcademy] Failed to start sandbox: ${error}`));
+    return {
+      url: "http://localhost:4321/api",
+      project: null,
+      cleanup: () => {}
+    };
+  }
+}
+
+// src/shell.html
+var shell_default = `<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Playcademy Dev Environment</title>
+        <script type="importmap">
+            {
+                "imports": {
+                    "@playcademy/sdk": "https://esm.sh/@playcademy/sdk@latest"
+                }
+            }
+        </script>
+        <style>
+            * {
+                margin: 0;
+                padding: 0;
+                box-sizing: border-box;
+            }
+
+            body {
+                display: flex;
+                flex-direction: column;
+                font-family: serif;
+                height: 100vh;
+            }
+
+            header {
+                padding: 0.5rem 1rem;
+                background-color: rgb(238, 238, 238);
+                border-bottom: 1px solid #ccc;
+            }
+
+            header h2 {
+                margin: 0;
+                padding: 0.2rem 0;
+                font-size: 1.25rem;
+            }
+
+            .header-content {
+                display: flex;
+                justify-content: space-between;
+                align-items: center;
+            }
+
+            .header-left {
+                flex: 1;
+            }
+
+            .user-info {
+                display: flex;
+                align-items: center;
+                gap: 1rem;
+            }
+
+            .status {
+                font-size: 0.9rem;
+                color: #666;
+            }
+
+            .game-container {
+                flex: 1;
+                position: relative;
+                overflow: hidden;
+                background-color: #f8f8f8;
+            }
+
+            .game-frame {
+                position: absolute;
+                inset: 0;
+                border: none;
+                width: 100%;
+                height: 100%;
+            }
+
+            .loading {
+                position: absolute;
+                inset: 0;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                color: #666;
+                font-size: 1.2rem;
+                background-color: #f8f8f8;
+            }
+
+            .error {
+                position: absolute;
+                inset: 0;
+                display: flex;
+                flex-direction: column;
+                align-items: center;
+                justify-content: center;
+                color: #d32f2f;
+                background-color: #ffebee;
+            }
+
+            .hidden {
+                display: none;
+            }
+        </style>
+    </head>
+    <body>
+        <header>
+            <div class="header-content">
+                <div class="header-left">
+                    <h2>Playcademy - Development</h2>
+                </div>
+                <div class="user-info">
+                    <div class="status" id="status"></div>
+                </div>
+            </div>
+        </header>
+
+        <div class="game-container">
+            <div class="loading" id="loading">Loading your game...</div>
+
+            <div class="error hidden" id="error">
+                <div>❌ Failed to load game</div>
+                <div
+                    style="margin-top: 0.5rem; font-size: 0.9rem; opacity: 0.8"
+                    id="errorMessage"
+                ></div>
+            </div>
+
+            <iframe
+                class="game-frame hidden"
+                id="gameFrame"
+                src="/game"
+            ></iframe>
+        </div>
+
+        <script type="module">
+            import { bus, BusEvents } from '@playcademy/sdk'
+
+            const status = document.getElementById('status')
+            const loading = document.getElementById('loading')
+            const error = document.getElementById('error')
+            const errorMessage = document.getElementById('errorMessage')
+            const gameFrame = document.getElementById('gameFrame')
+
+            const logIfDebug = (...args) => {
+                if (window.PLAYCADEMY_DEBUG) {
+                    console.log('[PlaycademyDevShell]', ...args)
+                }
+            }
+
+            logIfDebug('Playcademy Dev Shell initialized')
+
+            async function checkSandboxConnection() {
+                try {
+                    const response = await fetch('{{SANDBOX_URL}}/users/me', {
+                        headers: {
+                            Authorization: 'Bearer dev-token',
+                        },
+                    })
+
+                    if (response.ok) {
+                        status.textContent = ''
+                        logIfDebug('Sandbox API connection successful')
+                    } else {
+                        throw new Error('Sandbox API not available')
+                    }
+                } catch (err) {
+                    logIfDebug('Sandbox connection failed:', err)
+                    status.textContent = '⚠️ Sandbox Offline'
+                }
+            }
+
+            // Load the game iframe
+            function loadGame() {
+                gameFrame.onload = () => {
+                    loading.classList.add('hidden')
+                    gameFrame.classList.remove('hidden')
+
+                    logIfDebug(
+                        'Game iframe loaded, sending PLAYCADEMY_INIT message',
+                    )
+
+                    gameFrame.contentWindow.postMessage(
+                        {
+                            type: BusEvents.INIT,
+                            payload: {
+                                baseUrl: '{{SANDBOX_URL}}',
+                                token: 'dev-token',
+                                gameId: '{{GAME_ID}}',
+                            },
+                        },
+                        '*',
+                    )
+                }
+
+                gameFrame.onerror = () => {
+                    loading.classList.add('hidden')
+                    error.classList.remove('hidden')
+                    errorMessage.textContent = 'Game iframe failed to load'
+                    logIfDebug('Game iframe failed to load')
+                }
+
+                gameFrame.src = '/game'
+            }
+
+            window.addEventListener('message', event => {
+                if (event.source === gameFrame.contentWindow) {
+                    const { type, ...payload } = event.data || {}
+                    if (type && type.startsWith('PLAYCADEMY_')) {
+                        logIfDebug('Received message from game:', type, payload)
+                        bus.emit(type, payload)
+                    }
+                }
+            })
+
+            // Initialize
+            checkSandboxConnection()
+            loadGame()
+        </script>
+    </body>
+</html>
+`;
+
+// src/lib/server.ts
+function generateLoaderHTML(sandboxUrl, gameId) {
+  return shell_default.replace(/{{SANDBOX_URL}}/g, sandboxUrl).replace(/{{GAME_ID}}/g, gameId);
+}
+function devServerMiddleware(server, sandboxUrl, project) {
+  server.middlewares.use("/", (req, res, next) => {
+    if (req.url === "/" && req.method === "GET") {
+      res.setHeader("Content-Type", "text/html");
+      const gameId = project.slug;
+      res.end(generateLoaderHTML(sandboxUrl, gameId));
+      return;
+    }
+    next();
+  });
+}
+
+// src/lib/manifest.ts
+var import_archiver = __toESM(require_archiver(), 1);
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+import path2 from "node:path";
+import fs2 from "node:fs/promises";
+import { createWriteStream } from "node:fs";
+var LOG_LINE_TOTAL_WIDTH = 60;
 async function generatePlaycademyManifest(config, options, outDir, buildOutputs) {
   const manifestData = {
     version: "1",
     bootMode: options.bootMode,
     entryPoint: options.entryPoint,
     styles: options.styles || [],
-    engine: options.engine || "custom",
+    platform: options.platform || "web",
     createdAt: new Date().toISOString()
   };
-  const manifestPath = path.resolve(outDir, "playcademy.manifest.json");
+  const manifestPath = path2.resolve(outDir, "playcademy.manifest.json");
   const manifestJson = JSON.stringify(manifestData, null, 2);
-  await fs.writeFile(manifestPath, manifestJson);
+  await fs2.writeFile(manifestPath, manifestJson);
   try {
-    const stats = await fs.stat(manifestPath);
-    buildOutputs.manifestPath = path.relative(config.root, manifestPath);
+    const stats = await fs2.stat(manifestPath);
+    buildOutputs.manifestPath = path2.relative(config.root, manifestPath);
     buildOutputs.manifestSizeKb = (stats.size / 1024).toFixed(2);
   } catch (statError) {
     config.logger.warn(`[Playcademy] Could not get stats for manifest file: ${statError}`);
   }
 }
 async function createOutputZipArchive(config, outDir, buildOutputs) {
-  const projectRoot = path.resolve(config.root);
-  const projectName = path.basename(projectRoot);
-  const playcademyDir = path.resolve(projectRoot, ".playcademy");
-  await fs.mkdir(playcademyDir, { recursive: true });
+  const projectRoot = path2.resolve(config.root);
+  const projectName = path2.basename(projectRoot);
+  const playcademyDir = path2.resolve(projectRoot, ".playcademy");
+  await fs2.mkdir(playcademyDir, { recursive: true });
   const zipName = `${projectName}.zip`;
-  const zipOutPath = path.resolve(playcademyDir, zipName);
+  const zipOutPath = path2.resolve(playcademyDir, zipName);
   const output = createWriteStream(zipOutPath);
   const archive = import_archiver.default("zip", {
     zlib: { level: 9 }
   });
   await new Promise((resolve, reject) => {
     output.on("close", () => {
-      buildOutputs.zipPath = path.relative(config.root, zipOutPath);
+      buildOutputs.zipPath = path2.relative(config.root, zipOutPath);
       buildOutputs.zipSizeKb = (archive.pointer() / 1024).toFixed(2);
       resolve();
     });
@@ -40952,64 +41291,77 @@ function performPlaycademyLogging(config, buildOutputs) {
     return;
   }
   config.logger.info("");
-  config.logger.info(import_picocolors.default.magenta("[Playcademy]"));
+  config.logger.info(import_picocolors2.default.magenta("[Playcademy]"));
   if (buildOutputs.manifestPath && buildOutputs.manifestSizeKb) {
-    const dir = path.dirname(buildOutputs.manifestPath);
-    const file = path.basename(buildOutputs.manifestPath);
+    const dir = path2.dirname(buildOutputs.manifestPath);
+    const file = path2.basename(buildOutputs.manifestPath);
     const uncoloredPathLength = (dir === "." ? 0 : dir.length + 1) + file.length;
-    const coloredPath = `${import_picocolors.default.dim(dir === "." ? "" : dir + "/")}${import_picocolors.default.green(file)}`;
+    const coloredPath = `${import_picocolors2.default.dim(dir === "." ? "" : dir + "/")}${import_picocolors2.default.green(file)}`;
     const formattedNumber = formatNumberWithCommas(buildOutputs.manifestSizeKb);
     const sizeString = `${formattedNumber} kB`;
-    const formattedSize = import_picocolors.default.bold(import_picocolors.default.yellow(sizeString));
+    const formattedSize = import_picocolors2.default.bold(import_picocolors2.default.yellow(sizeString));
     const paddingNeeded = Math.max(2, LOG_LINE_TOTAL_WIDTH - uncoloredPathLength - sizeString.length);
     const paddingSpaces = " ".repeat(paddingNeeded);
     config.logger.info(`${coloredPath}${paddingSpaces}${formattedSize}`);
   }
   if (buildOutputs.zipPath && buildOutputs.zipSizeKb) {
-    let dir = path.dirname(buildOutputs.zipPath);
-    const file = path.basename(buildOutputs.zipPath);
+    let dir = path2.dirname(buildOutputs.zipPath);
+    const file = path2.basename(buildOutputs.zipPath);
     if (dir === ".")
       dir = "";
     const uncoloredPathLength = (dir ? dir.length + 1 : 0) + file.length;
-    const coloredPath = `${dir ? import_picocolors.default.dim(dir + "/") : ""}${import_picocolors.default.green(file)}`;
+    const coloredPath = `${dir ? import_picocolors2.default.dim(dir + "/") : ""}${import_picocolors2.default.green(file)}`;
     const formattedNumber = formatNumberWithCommas(buildOutputs.zipSizeKb);
     const sizeString = `${formattedNumber} kB`;
-    const formattedSize = import_picocolors.default.bold(import_picocolors.default.yellow(sizeString));
+    const formattedSize = import_picocolors2.default.bold(import_picocolors2.default.yellow(sizeString));
     const paddingNeeded = Math.max(2, LOG_LINE_TOTAL_WIDTH - uncoloredPathLength - sizeString.length);
     const paddingSpaces = " ".repeat(paddingNeeded);
     config.logger.info(`${coloredPath}${paddingSpaces}${formattedSize}`);
   }
   config.logger.info("");
 }
+
+// src/index.ts
 function playcademy(options = {}) {
   let viteConfig;
   let currentBuildOutputs = {};
-  const finalOptions = {
-    bootMode: options.bootMode ?? "iframe",
-    entryPoint: options.entryPoint ?? "index.html",
-    styles: options.styles ?? [],
-    engine: options.engine ?? "custom",
-    autoZip: process.env.CI === "true" ? false : options.autoZip ?? false
+  let sandboxCleanup = null;
+  const exportOptions = options.export ?? {};
+  const sandboxOptions = options.sandbox ?? {};
+  const _options = {
+    bootMode: exportOptions.bootMode ?? "iframe",
+    entryPoint: exportOptions.entryPoint ?? "index.html",
+    styles: exportOptions.styles ?? [],
+    platform: exportOptions.platform ?? "web",
+    autoZip: exportOptions.autoZip ?? false,
+    sandboxUrl: sandboxOptions.url ?? "http://localhost:4321/api",
+    startSandbox: sandboxOptions.autoStart ?? true,
+    verbose: sandboxOptions.verbose ?? false
   };
   return {
     name: "vite-plugin-playcademy",
     config(userConfig) {
-      if (userConfig.base === undefined) {
-        return {
-          base: "./"
-        };
-      }
-      return {};
+      return userConfig.base === undefined ? { base: "./" } : {};
     },
     configResolved(resolvedConfig) {
       viteConfig = resolvedConfig;
       currentBuildOutputs = {};
     },
+    async configureServer(server) {
+      const sandbox = await startSandbox(viteConfig, _options.startSandbox, _options.verbose);
+      sandboxCleanup = sandbox.cleanup;
+      if (sandbox.project) {
+        devServerMiddleware(server, sandbox.url, sandbox.project);
+      }
+      server.httpServer?.on("close", () => {
+        sandboxCleanup?.();
+      });
+    },
     async writeBundle() {
-      const outDir = viteConfig.build.outDir || path.join(process.cwd(), "dist");
+      const outDir = viteConfig.build.outDir || path3.join(process.cwd(), "dist");
       try {
-        await generatePlaycademyManifest(viteConfig, finalOptions, outDir, currentBuildOutputs);
-        if (finalOptions.autoZip) {
+        await generatePlaycademyManifest(viteConfig, _options, outDir, currentBuildOutputs);
+        if (_options.autoZip) {
           await createOutputZipArchive(viteConfig, outDir, currentBuildOutputs);
         }
       } catch (error) {