weapp-vite 5.2.0 → 5.2.1

package/dist/{chunk-UQ4TLG6L.mjs → chunk-74S2J7GW.mjs}

@@ -4,9 +4,9 @@ import {
   init_esm_shims
 } from "./chunk-7MAZ2JUY.mjs";
 
-// ../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/debug.js
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/debug.js
 var require_debug = __commonJS({
-  "../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/debug.js"(exports, module) {
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/debug.js"(exports, module) {
     "use strict";
     init_esm_shims();
     var debug4 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
@@ -15,9 +15,9 @@ var require_debug = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/constants.js
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/constants.js
 var require_constants = __commonJS({
-  "../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/constants.js"(exports, module) {
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/constants.js"(exports, module) {
     "use strict";
     init_esm_shims();
     var SEMVER_SPEC_VERSION = "2.0.0";
@@ -48,9 +48,9 @@ var require_constants = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/re.js
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/re.js
 var require_re = __commonJS({
-  "../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/re.js"(exports, module) {
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/re.js"(exports, module) {
     "use strict";
     init_esm_shims();
     var {
@@ -137,9 +137,9 @@ var require_re = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/parse-options.js
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/parse-options.js
 var require_parse_options = __commonJS({
-  "../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/parse-options.js"(exports, module) {
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/parse-options.js"(exports, module) {
     "use strict";
     init_esm_shims();
     var looseOption = Object.freeze({ loose: true });
@@ -157,13 +157,16 @@ var require_parse_options = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/identifiers.js
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/identifiers.js
 var require_identifiers = __commonJS({
-  "../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/identifiers.js"(exports, module) {
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/identifiers.js"(exports, module) {
     "use strict";
     init_esm_shims();
     var numeric = /^[0-9]+$/;
     var compareIdentifiers = (a, b) => {
+      if (typeof a === "number" && typeof b === "number") {
+        return a === b ? 0 : a < b ? -1 : 1;
+      }
       const anum = numeric.test(a);
       const bnum = numeric.test(b);
       if (anum && bnum) {
@@ -180,9 +183,9 @@ var require_identifiers = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/semver.js
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/semver.js
 var require_semver = __commonJS({
-  "../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/semver.js"(exports, module) {
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/semver.js"(exports, module) {
     "use strict";
     init_esm_shims();
     var debug4 = require_debug();
@@ -271,7 +274,25 @@ var require_semver = __commonJS({
         if (!(other instanceof _SemVer)) {
           other = new _SemVer(other, this.options);
         }
-        return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+        if (this.major < other.major) {
+          return -1;
+        }
+        if (this.major > other.major) {
+          return 1;
+        }
+        if (this.minor < other.minor) {
+          return -1;
+        }
+        if (this.minor > other.minor) {
+          return 1;
+        }
+        if (this.patch < other.patch) {
+          return -1;
+        }
+        if (this.patch > other.patch) {
+          return 1;
+        }
+        return 0;
       }
       comparePre(other) {
         if (!(other instanceof _SemVer)) {
@@ -442,9 +463,9 @@ var require_semver = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare.js
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare.js
 var require_compare = __commonJS({
-  "../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare.js"(exports, module) {
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare.js"(exports, module) {
     "use strict";
     init_esm_shims();
     var SemVer = require_semver();
@@ -453,9 +474,9 @@ var require_compare = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gte.js
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/gte.js
 var require_gte = __commonJS({
-  "../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gte.js"(exports, module) {
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/gte.js"(exports, module) {
     "use strict";
     init_esm_shims();
     var compare = require_compare();
@@ -975,6 +996,14 @@ async function findTemplateEntry(filepath) {
 function isTemplate(filepath) {
   return templateExtensions.some((ext2) => filepath.endsWith(`.${ext2}`));
 }
+async function touch(filename) {
+  const time = /* @__PURE__ */ new Date();
+  try {
+    await fs.utimes(filename, time, time);
+  } catch {
+    await fs.close(await fs.open(filename, "w"));
+  }
+}
 
 // src/utils/json.ts
 init_esm_shims();
@@ -2833,7 +2862,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path22) => statMethod(path22, { bigint: true });
+      this._stat = (path23) => statMethod(path23, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -2858,8 +2887,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path22, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path22));
+          const { path: path23, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path23));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -2899,20 +2928,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path22, depth) {
+  async _exploreDir(path23, depth) {
     let files;
     try {
-      files = await readdir(path22, this._rdOptions);
+      files = await readdir(path23, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path22 };
+    return { files, depth, path: path23 };
   }
-  async _formatEntry(dirent, path22) {
+  async _formatEntry(dirent, path23) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path22, basename4));
+      const fullPath = presolve(pjoin(path23, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -3313,16 +3342,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path22, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path23, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path22);
-    emitRaw(rawEvent, evPath, { watchedPath: path22 });
-    if (evPath && path22 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path22, evPath), KEY_LISTENERS, sysPath.join(path22, evPath));
+    listener(path23);
+    emitRaw(rawEvent, evPath, { watchedPath: path23 });
+    if (evPath && path23 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path23, evPath), KEY_LISTENERS, sysPath.join(path23, evPath));
     }
   };
   try {
-    return fs_watch(path22, {
+    return fs_watch(path23, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -3338,12 +3367,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path22, fullPath, options, handlers) => {
+var setFsWatchListener = (path23, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path22, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path23, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -3354,7 +3383,7 @@ var setFsWatchListener = (path22, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path22,
+      path23,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -3369,7 +3398,7 @@ var setFsWatchListener = (path22, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path22, "r");
+          const fd = await open(path23, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -3400,7 +3429,7 @@ var setFsWatchListener = (path22, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path22, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path23, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -3422,7 +3451,7 @@ var setFsWatchFileListener = (path22, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path22, curr));
+          foreach(cont.listeners, (listener2) => listener2(path23, curr));
         }
       })
     };
@@ -3450,13 +3479,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path22, listener) {
+  _watchWithNodeFs(path23, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path22);
-    const basename4 = sysPath.basename(path22);
+    const directory = sysPath.dirname(path23);
+    const basename4 = sysPath.basename(path23);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sysPath.resolve(path22);
+    const absolutePath = sysPath.resolve(path23);
     const options = {
       persistent: opts.persistent
     };
@@ -3466,12 +3495,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path22, absolutePath, options, {
+      closer = setFsWatchFileListener(path23, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path22, absolutePath, options, {
+      closer = setFsWatchListener(path23, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -3493,7 +3522,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path22, newStats) => {
+    const listener = async (path23, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -3507,11 +3536,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path22);
+            this.fsw._closeFile(path23);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path22, closer2);
+              this.fsw._addPathCloser(path23, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -3543,7 +3572,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path22, item) {
+  async _handleSymlink(entry, directory, path23, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -3553,7 +3582,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path22);
+        linkPath = await fsrealpath(path23);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -3563,12 +3592,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path22, entry.stats);
+          this.fsw._emit(EV.CHANGE, path23, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path22, entry.stats);
+        this.fsw._emit(EV.ADD, path23, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -3597,9 +3626,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path22 = sysPath.join(directory, item);
+      let path23 = sysPath.join(directory, item);
       current2.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path22, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path23, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -3608,8 +3637,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path22 = sysPath.join(dir, sysPath.relative(dir, path22));
-        this._addToNodeFs(path22, initialAdd, wh, depth + 1);
+        path23 = sysPath.join(dir, sysPath.relative(dir, path23));
+        this._addToNodeFs(path23, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve8, reject) => {
@@ -3678,13 +3707,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path22, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path23, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path22) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path23) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path22);
+    const wh = this.fsw._getWatchHelpers(path23);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -3700,8 +3729,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path22);
-        const targetPath = follow ? await fsrealpath(path22) : path22;
+        const absPath = sysPath.resolve(path23);
+        const targetPath = follow ? await fsrealpath(path23) : path23;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -3711,29 +3740,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path22) : path22;
+        const targetPath = follow ? await fsrealpath(path23) : path23;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path22, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path23, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path22), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path23), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path22, closer);
+        this.fsw._addPathCloser(path23, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path22;
+        return path23;
       }
     }
   }
@@ -3776,26 +3805,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path22) {
-  if (typeof path22 !== "string")
+function normalizePath(path23) {
+  if (typeof path23 !== "string")
     throw new Error("string expected");
-  path22 = sysPath2.normalize(path22);
-  path22 = path22.replace(/\\/g, "/");
+  path23 = sysPath2.normalize(path23);
+  path23 = path23.replace(/\\/g, "/");
   let prepend = false;
-  if (path22.startsWith("//"))
+  if (path23.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path22.match(DOUBLE_SLASH_RE2))
-    path22 = path22.replace(DOUBLE_SLASH_RE2, "/");
+  while (path23.match(DOUBLE_SLASH_RE2))
+    path23 = path23.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path22 = "/" + path22;
-  return path22;
+    path23 = "/" + path23;
+  return path23;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path22 = normalizePath(testString);
+  const path23 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path22, stats)) {
+    if (pattern(path23, stats)) {
       return true;
     }
   }
@@ -3835,19 +3864,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path22) => toUnix(sysPath2.normalize(toUnix(path22)));
-var normalizeIgnored = (cwd = "") => (path22) => {
-  if (typeof path22 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path22) ? path22 : sysPath2.join(cwd, path22));
+var normalizePathToUnix = (path23) => toUnix(sysPath2.normalize(toUnix(path23)));
+var normalizeIgnored = (cwd = "") => (path23) => {
+  if (typeof path23 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path23) ? path23 : sysPath2.join(cwd, path23));
   } else {
-    return path22;
+    return path23;
   }
 };
-var getAbsolutePath = (path22, cwd) => {
-  if (sysPath2.isAbsolute(path22)) {
-    return path22;
+var getAbsolutePath = (path23, cwd) => {
+  if (sysPath2.isAbsolute(path23)) {
+    return path23;
   }
-  return sysPath2.join(cwd, path22);
+  return sysPath2.join(cwd, path23);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -3902,10 +3931,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path22, follow, fsw) {
+  constructor(path23, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path22;
-    this.path = path22 = path22.replace(REPLACER_RE, "");
+    const watchPath = path23;
+    this.path = path23 = path23.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -4027,20 +4056,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path22) => {
-        const absPath = getAbsolutePath(path22, cwd);
+      paths = paths.map((path23) => {
+        const absPath = getAbsolutePath(path23, cwd);
         return absPath;
       });
     }
-    paths.forEach((path22) => {
-      this._removeIgnoredPath(path22);
+    paths.forEach((path23) => {
+      this._removeIgnoredPath(path23);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path22) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path22, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path23) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path23, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -4062,17 +4091,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path22) => {
-      if (!sysPath2.isAbsolute(path22) && !this._closers.has(path22)) {
+    paths.forEach((path23) => {
+      if (!sysPath2.isAbsolute(path23) && !this._closers.has(path23)) {
         if (cwd)
-          path22 = sysPath2.join(cwd, path22);
-        path22 = sysPath2.resolve(path22);
+          path23 = sysPath2.join(cwd, path23);
+        path23 = sysPath2.resolve(path23);
       }
-      this._closePath(path22);
-      this._addIgnoredPath(path22);
-      if (this._watched.has(path22)) {
+      this._closePath(path23);
+      this._addIgnoredPath(path23);
+      if (this._watched.has(path23)) {
         this._addIgnoredPath({
-          path: path22,
+          path: path23,
           recursive: true
         });
       }
@@ -4136,38 +4165,38 @@ var FSWatcher = class extends EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path22, stats) {
+  async _emit(event, path23, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path22 = sysPath2.normalize(path22);
+      path23 = sysPath2.normalize(path23);
     if (opts.cwd)
-      path22 = sysPath2.relative(opts.cwd, path22);
-    const args = [path22];
+      path23 = sysPath2.relative(opts.cwd, path23);
+    const args = [path23];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path22))) {
+    if (awf && (pw = this._pendingWrites.get(path23))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path22, [event, ...args]);
+        this._pendingUnlinks.set(path23, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path23) => {
+          this._pendingUnlinks.forEach((entry, path24) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path23);
+            this._pendingUnlinks.delete(path24);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path22)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path23)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path22);
+        this._pendingUnlinks.delete(path23);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -4185,16 +4214,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path22, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path23, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path22, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path23, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path22) : path22;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path23) : path23;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -4225,23 +4254,23 @@ var FSWatcher = class extends EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path22, timeout) {
+  _throttle(actionType, path23, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path22);
+    const actionPath = action.get(path23);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path22);
+      const item = action.get(path23);
       const count = item ? item.count : 0;
-      action.delete(path22);
+      action.delete(path23);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -4249,7 +4278,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path22, thr);
+    action.set(path23, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -4263,44 +4292,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path22, threshold, event, awfEmit) {
+  _awaitWriteFinish(path23, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path22;
-    if (this.options.cwd && !sysPath2.isAbsolute(path22)) {
-      fullPath = sysPath2.join(this.options.cwd, path22);
+    let fullPath = path23;
+    if (this.options.cwd && !sysPath2.isAbsolute(path23)) {
+      fullPath = sysPath2.join(this.options.cwd, path23);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path22)) {
+        if (err || !writes.has(path23)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path22).lastChange = now2;
+          writes.get(path23).lastChange = now2;
         }
-        const pw = writes.get(path22);
+        const pw = writes.get(path23);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path22);
+          writes.delete(path23);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path22)) {
-      writes.set(path22, {
+    if (!writes.has(path23)) {
+      writes.set(path23, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path22);
+          writes.delete(path23);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -4311,8 +4340,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path22, stats) {
-    if (this.options.atomic && DOT_RE.test(path22))
+  _isIgnored(path23, stats) {
+    if (this.options.atomic && DOT_RE.test(path23))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -4322,17 +4351,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path22, stats);
+    return this._userIgnored(path23, stats);
   }
-  _isntIgnored(path22, stat6) {
-    return !this._isIgnored(path22, stat6);
+  _isntIgnored(path23, stat6) {
+    return !this._isIgnored(path23, stat6);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path22) {
-    return new WatchHelper(path22, this.options.followSymlinks, this);
+  _getWatchHelpers(path23) {
+    return new WatchHelper(path23, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -4364,63 +4393,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path22 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path22);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path22) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path22, 100))
+    const path23 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path23);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path23) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path23, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path22);
+    const wp = this._getWatchedDir(path23);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path22, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path23, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path22;
+    let relPath = path23;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path22);
+      relPath = sysPath2.relative(this.options.cwd, path23);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path22);
+    this._watched.delete(path23);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path22))
-      this._emit(eventName, path22);
-    this._closePath(path22);
+    if (wasTracked && !this._isIgnored(path23))
+      this._emit(eventName, path23);
+    this._closePath(path23);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path22) {
-    this._closeFile(path22);
-    const dir = sysPath2.dirname(path22);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path22));
+  _closePath(path23) {
+    this._closeFile(path23);
+    const dir = sysPath2.dirname(path23);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path23));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path22) {
-    const closers = this._closers.get(path22);
+  _closeFile(path23) {
+    const closers = this._closers.get(path23);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path22);
+    this._closers.delete(path23);
   }
-  _addPathCloser(path22, closer) {
+  _addPathCloser(path23, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path22);
+    let list = this._closers.get(path23);
     if (!list) {
       list = [];
-      this._closers.set(path22, list);
+      this._closers.set(path23, list);
     }
     list.push(closer);
   }
@@ -6952,12 +6981,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path22) {
-    if (!path22) {
+  resolve(path23) {
+    if (!path23) {
       return this;
     }
-    const rootPath = this.getRootString(path22);
-    const dir = path22.substring(rootPath.length);
+    const rootPath = this.getRootString(path23);
+    const dir = path23.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -7709,8 +7738,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path22) {
-    return win32.parse(path22).root;
+  getRootString(path23) {
+    return win32.parse(path23).root;
   }
   /**
    * @internal
@@ -7756,8 +7785,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path22) {
-    return path22.startsWith("/") ? "/" : "";
+  getRootString(path23) {
+    return path23.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -7806,8 +7835,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs17 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs17);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs18 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs18);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = fileURLToPath(cwd);
     }
@@ -7846,11 +7875,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path22 = this.cwd) {
-    if (typeof path22 === "string") {
-      path22 = this.cwd.resolve(path22);
+  depth(path23 = this.cwd) {
+    if (typeof path23 === "string") {
+      path23 = this.cwd.resolve(path23);
     }
-    return path22.depth();
+    return path23.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -8229,7 +8258,7 @@ var PathScurryBase = class {
     const dirs = /* @__PURE__ */ new Set();
     const queue = [entry];
     let processing = 0;
-    const process8 = () => {
+    const process9 = () => {
       let paused = false;
       while (!paused) {
         const dir = queue.shift();
@@ -8270,9 +8299,9 @@ var PathScurryBase = class {
             }
           }
           if (paused && !results.flowing) {
-            results.once("drain", process8);
+            results.once("drain", process9);
           } else if (!sync2) {
-            process8();
+            process9();
           }
         };
         let sync2 = true;
@@ -8280,7 +8309,7 @@ var PathScurryBase = class {
         sync2 = false;
       }
     };
-    process8();
+    process9();
     return results;
   }
   streamSync(entry = this.cwd, opts = {}) {
@@ -8298,7 +8327,7 @@ var PathScurryBase = class {
     }
     const queue = [entry];
     let processing = 0;
-    const process8 = () => {
+    const process9 = () => {
       let paused = false;
       while (!paused) {
         const dir = queue.shift();
@@ -8332,14 +8361,14 @@ var PathScurryBase = class {
         }
       }
       if (paused && !results.flowing)
-        results.once("drain", process8);
+        results.once("drain", process9);
     };
-    process8();
+    process9();
     return results;
   }
-  chdir(path22 = this.cwd) {
+  chdir(path23 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path22 === "string" ? this.cwd.resolve(path22) : path22;
+    this.cwd = typeof path23 === "string" ? this.cwd.resolve(path23) : path23;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -8365,8 +8394,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs17) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs17 });
+  newRoot(fs18) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs18 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -8394,8 +8423,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs17) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs17 });
+  newRoot(fs18) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs18 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -8701,8 +8730,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path22, n2]) => [
-      path22,
+    return [...this.store.entries()].map(([path23, n2]) => [
+      path23,
       !!(n2 & 2),
       !!(n2 & 1)
     ]);
@@ -8907,9 +8936,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path22, opts) {
+  constructor(patterns, path23, opts) {
     this.patterns = patterns;
-    this.path = path22;
+    this.path = path23;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -8928,11 +8957,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path22) {
-    return this.seen.has(path22) || !!this.#ignore?.ignored?.(path22);
+  #ignored(path23) {
+    return this.seen.has(path23) || !!this.#ignore?.ignored?.(path23);
   }
-  #childrenIgnored(path22) {
-    return !!this.#ignore?.childrenIgnored?.(path22);
+  #childrenIgnored(path23) {
+    return !!this.#ignore?.childrenIgnored?.(path23);
   }
   // backpressure mechanism
   pause() {
@@ -9147,8 +9176,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path22, opts) {
-    super(patterns, path22, opts);
+  constructor(patterns, path23, opts) {
+    super(patterns, path23, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -9185,8 +9214,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path22, opts) {
-    super(patterns, path22, opts);
+  constructor(patterns, path23, opts) {
+    super(patterns, path23, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -9523,44 +9552,44 @@ init_esm_shims();
 var platform_default = process.env.__TESTING_RIMRAF_PLATFORM__ || process.platform;
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/path-arg.js
-var pathArg = (path22, opt = {}) => {
-  const type = typeof path22;
+var pathArg = (path23, opt = {}) => {
+  const type = typeof path23;
   if (type !== "string") {
-    const ctor = path22 && type === "object" && path22.constructor;
-    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? inspect(path22) : `type ${type} ${path22}`;
+    const ctor = path23 && type === "object" && path23.constructor;
+    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? inspect(path23) : `type ${type} ${path23}`;
     const msg = `The "path" argument must be of type string. Received ${received}`;
     throw Object.assign(new TypeError(msg), {
-      path: path22,
+      path: path23,
       code: "ERR_INVALID_ARG_TYPE"
     });
   }
-  if (/\0/.test(path22)) {
+  if (/\0/.test(path23)) {
     const msg = "path must be a string without null bytes";
     throw Object.assign(new TypeError(msg), {
-      path: path22,
+      path: path23,
       code: "ERR_INVALID_ARG_VALUE"
     });
   }
-  path22 = resolve3(path22);
-  const { root } = parse(path22);
-  if (path22 === root && opt.preserveRoot !== false) {
+  path23 = resolve3(path23);
+  const { root } = parse(path23);
+  if (path23 === root && opt.preserveRoot !== false) {
     const msg = "refusing to remove root directory without preserveRoot:false";
     throw Object.assign(new Error(msg), {
-      path: path22,
+      path: path23,
       code: "ERR_PRESERVE_ROOT"
     });
   }
   if (platform_default === "win32") {
     const badWinChars = /[*|"<>?:]/;
-    const { root: root2 } = parse(path22);
-    if (badWinChars.test(path22.substring(root2.length))) {
+    const { root: root2 } = parse(path23);
+    if (badWinChars.test(path23.substring(root2.length))) {
       throw Object.assign(new Error("Illegal characters in path."), {
-        path: path22,
+        path: path23,
         code: "EINVAL"
       });
     }
   }
-  return path22;
+  return path23;
 };
 var path_arg_default = pathArg;
 
@@ -9575,16 +9604,16 @@ init_esm_shims();
 import fs3 from "fs";
 import { chmodSync, mkdirSync, renameSync, rmdirSync, rmSync, statSync, lstatSync as lstatSync2, unlinkSync } from "fs";
 import { readdirSync as rdSync } from "fs";
-var readdirSync2 = (path22) => rdSync(path22, { withFileTypes: true });
-var chmod = (path22, mode) => new Promise((res, rej) => fs3.chmod(path22, mode, (er, ...d) => er ? rej(er) : res(...d)));
-var mkdir = (path22, options) => new Promise((res, rej) => fs3.mkdir(path22, options, (er, made) => er ? rej(er) : res(made)));
-var readdir4 = (path22) => new Promise((res, rej) => fs3.readdir(path22, { withFileTypes: true }, (er, data2) => er ? rej(er) : res(data2)));
+var readdirSync2 = (path23) => rdSync(path23, { withFileTypes: true });
+var chmod = (path23, mode) => new Promise((res, rej) => fs3.chmod(path23, mode, (er, ...d) => er ? rej(er) : res(...d)));
+var mkdir = (path23, options) => new Promise((res, rej) => fs3.mkdir(path23, options, (er, made) => er ? rej(er) : res(made)));
+var readdir4 = (path23) => new Promise((res, rej) => fs3.readdir(path23, { withFileTypes: true }, (er, data2) => er ? rej(er) : res(data2)));
 var rename = (oldPath, newPath) => new Promise((res, rej) => fs3.rename(oldPath, newPath, (er, ...d) => er ? rej(er) : res(...d)));
-var rm = (path22, options) => new Promise((res, rej) => fs3.rm(path22, options, (er, ...d) => er ? rej(er) : res(...d)));
-var rmdir = (path22) => new Promise((res, rej) => fs3.rmdir(path22, (er, ...d) => er ? rej(er) : res(...d)));
-var stat4 = (path22) => new Promise((res, rej) => fs3.stat(path22, (er, data2) => er ? rej(er) : res(data2)));
-var lstat4 = (path22) => new Promise((res, rej) => fs3.lstat(path22, (er, data2) => er ? rej(er) : res(data2)));
-var unlink = (path22) => new Promise((res, rej) => fs3.unlink(path22, (er, ...d) => er ? rej(er) : res(...d)));
+var rm = (path23, options) => new Promise((res, rej) => fs3.rm(path23, options, (er, ...d) => er ? rej(er) : res(...d)));
+var rmdir = (path23) => new Promise((res, rej) => fs3.rmdir(path23, (er, ...d) => er ? rej(er) : res(...d)));
+var stat4 = (path23) => new Promise((res, rej) => fs3.stat(path23, (er, data2) => er ? rej(er) : res(data2)));
+var lstat4 = (path23) => new Promise((res, rej) => fs3.lstat(path23, (er, data2) => er ? rej(er) : res(data2)));
+var unlink = (path23) => new Promise((res, rej) => fs3.unlink(path23, (er, ...d) => er ? rej(er) : res(...d)));
 var promises = {
   chmod,
   mkdir,
@@ -9603,10 +9632,10 @@ import { parse as parse2, resolve as resolve4 } from "path";
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/readdir-or-error.js
 init_esm_shims();
 var { readdir: readdir5 } = promises;
-var readdirOrError = (path22) => readdir5(path22).catch((er) => er);
-var readdirOrErrorSync = (path22) => {
+var readdirOrError = (path23) => readdir5(path23).catch((er) => er);
+var readdirOrErrorSync = (path23) => {
   try {
-    return readdirSync2(path22);
+    return readdirSync2(path23);
   } catch (er) {
     return er;
   }
@@ -9631,35 +9660,35 @@ var ignoreENOENTSync = (fn) => {
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/rimraf-posix.js
 var { lstat: lstat5, rmdir: rmdir2, unlink: unlink2 } = promises;
-var rimrafPosix = async (path22, opt) => {
+var rimrafPosix = async (path23, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafPosixDir(path22, opt, await lstat5(path22));
+    return await rimrafPosixDir(path23, opt, await lstat5(path23));
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafPosixSync = (path22, opt) => {
+var rimrafPosixSync = (path23, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafPosixDirSync(path22, opt, lstatSync2(path22));
+    return rimrafPosixDirSync(path23, opt, lstatSync2(path23));
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafPosixDir = async (path22, opt, ent) => {
+var rimrafPosixDir = async (path23, opt, ent) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path22) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path23) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -9669,30 +9698,30 @@ var rimrafPosixDir = async (path22, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path22, ent)) {
+    if (opt.filter && !await opt.filter(path23, ent)) {
       return false;
     }
-    await ignoreENOENT(unlink2(path22));
+    await ignoreENOENT(unlink2(path23));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(resolve4(path22, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(resolve4(path23, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path22 === parse2(path22).root) {
+  if (opt.preserveRoot === false && path23 === parse2(path23).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path22, ent)) {
+  if (opt.filter && !await opt.filter(path23, ent)) {
     return false;
   }
-  await ignoreENOENT(rmdir2(path22));
+  await ignoreENOENT(rmdir2(path23));
   return true;
 };
-var rimrafPosixDirSync = (path22, opt, ent) => {
+var rimrafPosixDirSync = (path23, opt, ent) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path22) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path23) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -9702,27 +9731,27 @@ var rimrafPosixDirSync = (path22, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path22, ent)) {
+    if (opt.filter && !opt.filter(path23, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => unlinkSync(path22));
+    ignoreENOENTSync(() => unlinkSync(path23));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = resolve4(path22, ent2.name);
+    const p = resolve4(path23, ent2.name);
     removedAll = rimrafPosixDirSync(p, opt, ent2) && removedAll;
   }
-  if (opt.preserveRoot === false && path22 === parse2(path22).root) {
+  if (opt.preserveRoot === false && path23 === parse2(path23).root) {
     return false;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.filter && !opt.filter(path22, ent)) {
+  if (opt.filter && !opt.filter(path23, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => rmdirSync(path22));
+  ignoreENOENTSync(() => rmdirSync(path23));
   return true;
 };
 
@@ -9733,9 +9762,9 @@ import { parse as parse5, resolve as resolve7 } from "path";
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/fix-eperm.js
 init_esm_shims();
 var { chmod: chmod2 } = promises;
-var fixEPERM = (fn) => async (path22) => {
+var fixEPERM = (fn) => async (path23) => {
   try {
-    return await fn(path22);
+    return await fn(path23);
   } catch (er) {
     const fer = er;
     if (fer?.code === "ENOENT") {
@@ -9743,7 +9772,7 @@ var fixEPERM = (fn) => async (path22) => {
     }
     if (fer?.code === "EPERM") {
       try {
-        await chmod2(path22, 438);
+        await chmod2(path23, 438);
       } catch (er2) {
         const fer2 = er2;
         if (fer2?.code === "ENOENT") {
@@ -9751,14 +9780,14 @@ var fixEPERM = (fn) => async (path22) => {
         }
         throw er;
       }
-      return await fn(path22);
+      return await fn(path23);
     }
     throw er;
   }
 };
-var fixEPERMSync = (fn) => (path22) => {
+var fixEPERMSync = (fn) => (path23) => {
   try {
-    return fn(path22);
+    return fn(path23);
   } catch (er) {
     const fer = er;
     if (fer?.code === "ENOENT") {
@@ -9766,7 +9795,7 @@ var fixEPERMSync = (fn) => (path22) => {
     }
     if (fer?.code === "EPERM") {
       try {
-        chmodSync(path22, 438);
+        chmodSync(path23, 438);
       } catch (er2) {
         const fer2 = er2;
         if (fer2?.code === "ENOENT") {
@@ -9774,7 +9803,7 @@ var fixEPERMSync = (fn) => (path22) => {
         }
         throw er;
       }
-      return fn(path22);
+      return fn(path23);
     }
     throw er;
   }
@@ -9787,23 +9816,23 @@ var RATE = 1.2;
 var MAXRETRIES = 10;
 var codes = /* @__PURE__ */ new Set(["EMFILE", "ENFILE", "EBUSY"]);
 var retryBusy = (fn) => {
-  const method = async (path22, opt, backoff = 1, total = 0) => {
+  const method = async (path23, opt, backoff = 1, total = 0) => {
     const mbo = opt.maxBackoff || MAXBACKOFF;
     const rate = opt.backoff || RATE;
     const max = opt.maxRetries || MAXRETRIES;
     let retries = 0;
     while (true) {
       try {
-        return await fn(path22);
+        return await fn(path23);
       } catch (er) {
         const fer = er;
-        if (fer?.path === path22 && fer?.code && codes.has(fer.code)) {
+        if (fer?.path === path23 && fer?.code && codes.has(fer.code)) {
           backoff = Math.ceil(backoff * rate);
           total = backoff + total;
           if (total < mbo) {
             return new Promise((res, rej) => {
               setTimeout(() => {
-                method(path22, opt, backoff, total).then(res, rej);
+                method(path23, opt, backoff, total).then(res, rej);
               }, backoff);
             });
           }
@@ -9819,15 +9848,15 @@ var retryBusy = (fn) => {
   return method;
 };
 var retryBusySync = (fn) => {
-  const method = (path22, opt) => {
+  const method = (path23, opt) => {
     const max = opt.maxRetries || MAXRETRIES;
     let retries = 0;
     while (true) {
       try {
-        return fn(path22);
+        return fn(path23);
       } catch (er) {
         const fer = er;
-        if (fer?.path === path22 && fer?.code && codes.has(fer.code) && retries < max) {
+        if (fer?.path === path23 && fer?.code && codes.has(fer.code) && retries < max) {
           retries++;
           continue;
         }
@@ -9847,16 +9876,16 @@ init_esm_shims();
 import { tmpdir } from "os";
 import { parse as parse3, resolve as resolve5 } from "path";
 var { stat: stat5 } = promises;
-var isDirSync = (path22) => {
+var isDirSync = (path23) => {
   try {
-    return statSync(path22).isDirectory();
+    return statSync(path23).isDirectory();
   } catch (er) {
     return false;
   }
 };
-var isDir = (path22) => stat5(path22).then((st) => st.isDirectory(), () => false);
-var win32DefaultTmp = async (path22) => {
-  const { root } = parse3(path22);
+var isDir = (path23) => stat5(path23).then((st) => st.isDirectory(), () => false);
+var win32DefaultTmp = async (path23) => {
+  const { root } = parse3(path23);
   const tmp = tmpdir();
   const { root: tmpRoot } = parse3(tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -9868,8 +9897,8 @@ var win32DefaultTmp = async (path22) => {
   }
   return root;
 };
-var win32DefaultTmpSync = (path22) => {
-  const { root } = parse3(path22);
+var win32DefaultTmpSync = (path23) => {
+  const { root } = parse3(path23);
   const tmp = tmpdir();
   const { root: tmpRoot } = parse3(tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -9888,10 +9917,10 @@ var defaultTmpSync = platform_default === "win32" ? win32DefaultTmpSync : posixD
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/rimraf-move-remove.js
 var { lstat: lstat6, rename: rename2, unlink: unlink3, rmdir: rmdir3, chmod: chmod3 } = promises;
-var uniqueFilename = (path22) => `.${basename3(path22)}.${Math.random()}`;
-var unlinkFixEPERM = async (path22) => unlink3(path22).catch((er) => {
+var uniqueFilename = (path23) => `.${basename3(path23)}.${Math.random()}`;
+var unlinkFixEPERM = async (path23) => unlink3(path23).catch((er) => {
   if (er.code === "EPERM") {
-    return chmod3(path22, 438).then(() => unlink3(path22), (er2) => {
+    return chmod3(path23, 438).then(() => unlink3(path23), (er2) => {
       if (er2.code === "ENOENT") {
         return;
       }
@@ -9902,13 +9931,13 @@ var unlinkFixEPERM = async (path22) => unlink3(path22).catch((er) => {
   }
   throw er;
 });
-var unlinkFixEPERMSync = (path22) => {
+var unlinkFixEPERMSync = (path23) => {
   try {
-    unlinkSync(path22);
+    unlinkSync(path23);
   } catch (er) {
     if (er?.code === "EPERM") {
       try {
-        return chmodSync(path22, 438);
+        return chmodSync(path23, 438);
       } catch (er2) {
         if (er2?.code === "ENOENT") {
           return;
@@ -9921,29 +9950,29 @@ var unlinkFixEPERMSync = (path22) => {
     throw er;
   }
 };
-var rimrafMoveRemove = async (path22, opt) => {
+var rimrafMoveRemove = async (path23, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafMoveRemoveDir(path22, opt, await lstat6(path22));
+    return await rimrafMoveRemoveDir(path23, opt, await lstat6(path23));
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafMoveRemoveDir = async (path22, opt, ent) => {
+var rimrafMoveRemoveDir = async (path23, opt, ent) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   if (!opt.tmp) {
-    return rimrafMoveRemoveDir(path22, { ...opt, tmp: await defaultTmp(path22) }, ent);
+    return rimrafMoveRemoveDir(path23, { ...opt, tmp: await defaultTmp(path23) }, ent);
   }
-  if (path22 === opt.tmp && parse4(path22).root !== path22) {
+  if (path23 === opt.tmp && parse4(path23).root !== path23) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path22) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path23) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -9953,54 +9982,54 @@ var rimrafMoveRemoveDir = async (path22, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path22, ent)) {
+    if (opt.filter && !await opt.filter(path23, ent)) {
       return false;
     }
-    await ignoreENOENT(tmpUnlink(path22, opt.tmp, unlinkFixEPERM));
+    await ignoreENOENT(tmpUnlink(path23, opt.tmp, unlinkFixEPERM));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(resolve6(path22, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(resolve6(path23, ent2.name), opt, ent2)))).reduce((a, b) => a && b, true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path22 === parse4(path22).root) {
+  if (opt.preserveRoot === false && path23 === parse4(path23).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path22, ent)) {
+  if (opt.filter && !await opt.filter(path23, ent)) {
     return false;
   }
-  await ignoreENOENT(tmpUnlink(path22, opt.tmp, rmdir3));
+  await ignoreENOENT(tmpUnlink(path23, opt.tmp, rmdir3));
   return true;
 };
-var tmpUnlink = async (path22, tmp, rm3) => {
-  const tmpFile = resolve6(tmp, uniqueFilename(path22));
-  await rename2(path22, tmpFile);
+var tmpUnlink = async (path23, tmp, rm3) => {
+  const tmpFile = resolve6(tmp, uniqueFilename(path23));
+  await rename2(path23, tmpFile);
   return await rm3(tmpFile);
 };
-var rimrafMoveRemoveSync = (path22, opt) => {
+var rimrafMoveRemoveSync = (path23, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafMoveRemoveDirSync(path22, opt, lstatSync2(path22));
+    return rimrafMoveRemoveDirSync(path23, opt, lstatSync2(path23));
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafMoveRemoveDirSync = (path22, opt, ent) => {
+var rimrafMoveRemoveDirSync = (path23, opt, ent) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   if (!opt.tmp) {
-    return rimrafMoveRemoveDirSync(path22, { ...opt, tmp: defaultTmpSync(path22) }, ent);
+    return rimrafMoveRemoveDirSync(path23, { ...opt, tmp: defaultTmpSync(path23) }, ent);
   }
   const tmp = opt.tmp;
-  if (path22 === opt.tmp && parse4(path22).root !== path22) {
+  if (path23 === opt.tmp && parse4(path23).root !== path23) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path22) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path23) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -10010,32 +10039,32 @@ var rimrafMoveRemoveDirSync = (path22, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path22, ent)) {
+    if (opt.filter && !opt.filter(path23, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => tmpUnlinkSync(path22, tmp, unlinkFixEPERMSync));
+    ignoreENOENTSync(() => tmpUnlinkSync(path23, tmp, unlinkFixEPERMSync));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = resolve6(path22, ent2.name);
+    const p = resolve6(path23, ent2.name);
     removedAll = rimrafMoveRemoveDirSync(p, opt, ent2) && removedAll;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path22 === parse4(path22).root) {
+  if (opt.preserveRoot === false && path23 === parse4(path23).root) {
     return false;
   }
-  if (opt.filter && !opt.filter(path22, ent)) {
+  if (opt.filter && !opt.filter(path23, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => tmpUnlinkSync(path22, tmp, rmdirSync));
+  ignoreENOENTSync(() => tmpUnlinkSync(path23, tmp, rmdirSync));
   return true;
 };
-var tmpUnlinkSync = (path22, tmp, rmSync2) => {
-  const tmpFile = resolve6(tmp, uniqueFilename(path22));
-  renameSync(path22, tmpFile);
+var tmpUnlinkSync = (path23, tmp, rmSync2) => {
+  const tmpFile = resolve6(tmp, uniqueFilename(path23));
+  renameSync(path23, tmpFile);
   return rmSync2(tmpFile);
 };
 
@@ -10045,31 +10074,31 @@ var rimrafWindowsFile = retryBusy(fixEPERM(unlink4));
 var rimrafWindowsFileSync = retryBusySync(fixEPERMSync(unlinkSync));
 var rimrafWindowsDirRetry = retryBusy(fixEPERM(rmdir4));
 var rimrafWindowsDirRetrySync = retryBusySync(fixEPERMSync(rmdirSync));
-var rimrafWindowsDirMoveRemoveFallback = async (path22, opt) => {
+var rimrafWindowsDirMoveRemoveFallback = async (path23, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   const { filter: filter3, ...options } = opt;
   try {
-    return await rimrafWindowsDirRetry(path22, options);
+    return await rimrafWindowsDirRetry(path23, options);
   } catch (er) {
     if (er?.code === "ENOTEMPTY") {
-      return await rimrafMoveRemove(path22, options);
+      return await rimrafMoveRemove(path23, options);
     }
     throw er;
   }
 };
-var rimrafWindowsDirMoveRemoveFallbackSync = (path22, opt) => {
+var rimrafWindowsDirMoveRemoveFallbackSync = (path23, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   const { filter: filter3, ...options } = opt;
   try {
-    return rimrafWindowsDirRetrySync(path22, options);
+    return rimrafWindowsDirRetrySync(path23, options);
   } catch (er) {
     const fer = er;
     if (fer?.code === "ENOTEMPTY") {
-      return rimrafMoveRemoveSync(path22, options);
+      return rimrafMoveRemoveSync(path23, options);
     }
     throw er;
   }
@@ -10077,35 +10106,35 @@ var rimrafWindowsDirMoveRemoveFallbackSync = (path22, opt) => {
 var START = Symbol("start");
 var CHILD = Symbol("child");
 var FINISH = Symbol("finish");
-var rimrafWindows = async (path22, opt) => {
+var rimrafWindows = async (path23, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return await rimrafWindowsDir(path22, opt, await lstat7(path22), START);
+    return await rimrafWindowsDir(path23, opt, await lstat7(path23), START);
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafWindowsSync = (path22, opt) => {
+var rimrafWindowsSync = (path23, opt) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
   try {
-    return rimrafWindowsDirSync(path22, opt, lstatSync2(path22), START);
+    return rimrafWindowsDirSync(path23, opt, lstatSync2(path23), START);
   } catch (er) {
     if (er?.code === "ENOENT")
       return true;
     throw er;
   }
 };
-var rimrafWindowsDir = async (path22, opt, ent, state = START) => {
+var rimrafWindowsDir = async (path23, opt, ent, state = START) => {
   if (opt?.signal?.aborted) {
     throw opt.signal.reason;
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path22) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path23) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -10115,32 +10144,32 @@ var rimrafWindowsDir = async (path22, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path22, ent)) {
+    if (opt.filter && !await opt.filter(path23, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsFile(path22, opt));
+    await ignoreENOENT(rimrafWindowsFile(path23, opt));
     return true;
   }
   const s = state === START ? CHILD : state;
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(resolve7(path22, ent2.name), opt, ent2, s)))).reduce((a, b) => a && b, true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(resolve7(path23, ent2.name), opt, ent2, s)))).reduce((a, b) => a && b, true);
   if (state === START) {
-    return rimrafWindowsDir(path22, opt, ent, FINISH);
+    return rimrafWindowsDir(path23, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path22 === parse5(path22).root) {
+    if (opt.preserveRoot === false && path23 === parse5(path23).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !await opt.filter(path22, ent)) {
+    if (opt.filter && !await opt.filter(path23, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path22, opt));
+    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path23, opt));
   }
   return true;
 };
-var rimrafWindowsDirSync = (path22, opt, ent, state = START) => {
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path22) : null;
+var rimrafWindowsDirSync = (path23, opt, ent, state = START) => {
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path23) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (entries.code === "ENOENT") {
@@ -10150,32 +10179,32 @@ var rimrafWindowsDirSync = (path22, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path22, ent)) {
+    if (opt.filter && !opt.filter(path23, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => rimrafWindowsFileSync(path22, opt));
+    ignoreENOENTSync(() => rimrafWindowsFileSync(path23, opt));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
     const s = state === START ? CHILD : state;
-    const p = resolve7(path22, ent2.name);
+    const p = resolve7(path23, ent2.name);
     removedAll = rimrafWindowsDirSync(p, opt, ent2, s) && removedAll;
   }
   if (state === START) {
-    return rimrafWindowsDirSync(path22, opt, ent, FINISH);
+    return rimrafWindowsDirSync(path23, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path22 === parse5(path22).root) {
+    if (opt.preserveRoot === false && path23 === parse5(path23).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !opt.filter(path22, ent)) {
+    if (opt.filter && !opt.filter(path23, ent)) {
       return false;
     }
     ignoreENOENTSync(() => {
-      rimrafWindowsDirMoveRemoveFallbackSync(path22, opt);
+      rimrafWindowsDirMoveRemoveFallbackSync(path23, opt);
     });
   }
   return true;
@@ -10188,16 +10217,16 @@ var rimrafManualSync = platform_default === "win32" ? rimrafWindowsSync : rimraf
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/rimraf-native.js
 init_esm_shims();
 var { rm: rm2 } = promises;
-var rimrafNative = async (path22, opt) => {
-  await rm2(path22, {
+var rimrafNative = async (path23, opt) => {
+  await rm2(path23, {
     ...opt,
     force: true,
     recursive: true
   });
   return true;
 };
-var rimrafNativeSync = (path22, opt) => {
-  rmSync(path22, {
+var rimrafNativeSync = (path23, opt) => {
+  rmSync(path23, {
     ...opt,
     force: true,
     recursive: true
@@ -10215,26 +10244,26 @@ var useNative = !hasNative || platform_default === "win32" ? () => false : (opt)
 var useNativeSync = !hasNative || platform_default === "win32" ? () => false : (opt) => !opt?.signal && !opt?.filter;
 
 // ../../node_modules/.pnpm/rimraf@6.0.1/node_modules/rimraf/dist/esm/index.js
-var wrap = (fn) => async (path22, opt) => {
+var wrap = (fn) => async (path23, opt) => {
   const options = optArg(opt);
   if (options.glob) {
-    path22 = await glob(path22, options.glob);
+    path23 = await glob(path23, options.glob);
   }
-  if (Array.isArray(path22)) {
-    return !!(await Promise.all(path22.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
+  if (Array.isArray(path23)) {
+    return !!(await Promise.all(path23.map((p) => fn(path_arg_default(p, options), options)))).reduce((a, b) => a && b, true);
   } else {
-    return !!await fn(path_arg_default(path22, options), options);
+    return !!await fn(path_arg_default(path23, options), options);
   }
 };
-var wrapSync = (fn) => (path22, opt) => {
+var wrapSync = (fn) => (path23, opt) => {
   const options = optArgSync(opt);
   if (options.glob) {
-    path22 = globSync(path22, options.glob);
+    path23 = globSync(path23, options.glob);
   }
-  if (Array.isArray(path22)) {
-    return !!path22.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
+  if (Array.isArray(path23)) {
+    return !!path23.map((p) => fn(path_arg_default(p, options), options)).reduce((a, b) => a && b, true);
   } else {
-    return !!fn(path_arg_default(path22, options), options);
+    return !!fn(path_arg_default(path23, options), options);
   }
 };
 var nativeSync = wrapSync(rimrafNativeSync);
@@ -10249,8 +10278,8 @@ var moveRemoveSync = wrapSync(rimrafMoveRemoveSync);
 var moveRemove = Object.assign(wrap(rimrafMoveRemove), {
   sync: moveRemoveSync
 });
-var rimrafSync = wrapSync((path22, opt) => useNativeSync(opt) ? rimrafNativeSync(path22, opt) : rimrafManualSync(path22, opt));
-var rimraf_ = wrap((path22, opt) => useNative(opt) ? rimrafNative(path22, opt) : rimrafManual(path22, opt));
+var rimrafSync = wrapSync((path23, opt) => useNativeSync(opt) ? rimrafNativeSync(path23, opt) : rimrafManualSync(path23, opt));
+var rimraf_ = wrap((path23, opt) => useNative(opt) ? rimrafNative(path23, opt) : rimrafManual(path23, opt));
 var rimraf = Object.assign(rimraf_, {
   rimraf: rimraf_,
   sync: rimrafSync,
@@ -10476,9 +10505,9 @@ function createBuildServicePlugin(ctx) {
 
 // src/runtime/configPlugin.ts
 init_esm_shims();
-import process6 from "process";
+import process7 from "process";
 import { defu as defu3 } from "@weapp-core/shared";
-import fs12 from "fs-extra";
+import fs13 from "fs-extra";
 
 // ../../node_modules/.pnpm/local-pkg@1.1.2/node_modules/local-pkg/dist/index.mjs
 init_esm_shims();
@@ -16124,17 +16153,17 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path22 = input;
+  let path23 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex !== -1) {
-    path22 = input.slice(0, fragmentIndex);
+    path23 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path22) {
+    if (!path23) {
       return fragment;
     }
   }
-  const [s0, ...s] = path22.split("?");
+  const [s0, ...s] = path23.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -16163,8 +16192,8 @@ import path7, { dirname as dirname3 } from "path";
 import v8 from "v8";
 import { format, inspect as inspect2 } from "util";
 var BUILTIN_MODULES = new Set(builtinModules);
-function normalizeSlash(path22) {
-  return path22.replace(/\\/g, "/");
+function normalizeSlash(path23) {
+  return path23.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -16277,8 +16306,8 @@ codes2.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path22, base, message) => {
-    return `Invalid package config ${path22}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path23, base, message) => {
+    return `Invalid package config ${path23}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -16310,8 +16339,8 @@ codes2.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path22, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path22}' imported from ${base}`;
+  (path23, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path23}' imported from ${base}`;
   },
   Error
 );
@@ -16362,8 +16391,8 @@ codes2.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path22) => {
-    return `Unknown file extension "${extension}" for ${path22}`;
+  (extension, path23) => {
+    return `Unknown file extension "${extension}" for ${path23}`;
   },
   TypeError
 );
@@ -16734,9 +16763,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path22) {
+function tryStatSync(path23) {
   try {
-    return statSync2(path22);
+    return statSync2(path23);
   } catch {
   }
 }
@@ -17655,7 +17684,7 @@ function findUpSync(name, {
     directory = path8.dirname(directory);
   }
 }
-function _resolve2(path22, options = {}) {
+function _resolve2(path23, options = {}) {
   if (options.platform === "auto" || !options.platform)
     options.platform = process4.platform === "win32" ? "win32" : "posix";
   if (process4.versions.pnp) {
@@ -17664,11 +17693,11 @@ function _resolve2(path22, options = {}) {
       paths.push(process4.cwd());
     const targetRequire = createRequire2(import.meta.url);
     try {
-      return targetRequire.resolve(path22, { paths });
+      return targetRequire.resolve(path23, { paths });
     } catch {
     }
   }
-  const modulePath = resolvePathSync(path22, {
+  const modulePath = resolvePathSync(path23, {
     url: options.paths
   });
   if (options.platform === "win32")
@@ -17739,10 +17768,10 @@ var findUp = quansync2({
   async: findUp$1
 });
 var loadPackageJSON = quansync2(function* (cwd = process4.cwd()) {
-  const path22 = yield findUp("package.json", { cwd });
-  if (!path22 || !fs5.existsSync(path22))
+  const path23 = yield findUp("package.json", { cwd });
+  if (!path23 || !fs5.existsSync(path23))
     return null;
-  return JSON.parse(yield readFile(path22));
+  return JSON.parse(yield readFile(path23));
 });
 var loadPackageJSONSync = loadPackageJSON.sync;
 var isPackageListed = quansync2(function* (name, cwd) {
@@ -17795,9 +17824,9 @@ var INSTALL_METADATA = {
 };
 
 // ../../node_modules/.pnpm/package-manager-detector@1.4.0/node_modules/package-manager-detector/dist/detect.mjs
-async function pathExists(path22, type) {
+async function pathExists(path23, type) {
   try {
-    const stat6 = await fs6.stat(path22);
+    const stat6 = await fs6.stat(path23);
     return type === "file" ? stat6.isFile() : stat6.isDirectory();
   } catch {
     return false;
@@ -17914,7 +17943,7 @@ function isMetadataYarnClassic(metadataPath) {
 }
 
 // src/runtime/configPlugin.ts
-import path18 from "pathe";
+import path19 from "pathe";
 import { loadConfigFromFile } from "vite";
 import tsconfigPaths from "vite-tsconfig-paths";
 
@@ -18207,8 +18236,8 @@ function matchesAutoImportGlobs(ctx, candidate) {
 // src/plugins/core.ts
 init_esm_shims();
 import { isEmptyObject as isEmptyObject2, isObject as isObject6, removeExtensionDeep as removeExtensionDeep4 } from "@weapp-core/shared";
-import fs9 from "fs-extra";
-import path15 from "pathe";
+import fs10 from "fs-extra";
+import path16 from "pathe";
 import { build as build2 } from "vite";
 
 // src/wxml/handle.ts
@@ -19652,7 +19681,7 @@ function createEntryLoader(options) {
     const jsonEntry = await findJsonEntry(id);
     let jsonPath = jsonEntry.path;
     for (const prediction of jsonEntry.predictions) {
-      this.addWatchFile(prediction);
+      await addWatchTarget(this, prediction);
     }
     let json = {};
     if (jsonPath) {
@@ -19732,7 +19761,7 @@ async function collectAppSideFiles(pluginCtx, id, json, jsonService, registerJso
       path13.resolve(path13.dirname(id), location)
     );
     for (const prediction of predictions) {
-      pluginCtx.addWatchFile(prediction);
+      await addWatchTarget(pluginCtx, prediction);
     }
     if (!jsonPath) {
       return;
@@ -19750,7 +19779,7 @@ async function collectAppSideFiles(pluginCtx, id, json, jsonService, registerJso
 async function ensureTemplateScanned(pluginCtx, id, scanTemplateEntry) {
   const { path: templateEntry, predictions } = await findTemplateEntry(id);
   for (const prediction of predictions) {
-    pluginCtx.addWatchFile(prediction);
+    await addWatchTarget(pluginCtx, prediction);
   }
   if (!templateEntry) {
     return "";
@@ -19772,13 +19801,23 @@ async function resolveEntries(entries, absoluteSrcRoot) {
 async function prependStyleImports(id, ms) {
   for (const ext2 of supportedCssLangs) {
     const mayBeCssPath = changeFileExtension(id, ext2);
-    this.addWatchFile(mayBeCssPath);
-    if (await fs8.exists(mayBeCssPath)) {
+    const exists = await addWatchTarget(this, mayBeCssPath);
+    if (exists) {
       ms.prepend(`import '${mayBeCssPath}';
 `);
     }
   }
 }
+async function addWatchTarget(pluginCtx, target) {
+  if (!target || typeof pluginCtx.addWatchFile !== "function") {
+    return false;
+  }
+  const exists = await fs8.exists(target);
+  if (exists) {
+    pluginCtx.addWatchFile(target);
+  }
+  return exists;
+}
 
 // src/plugins/hooks/useLoadEntry/normalizer.ts
 init_esm_shims();
@@ -19896,6 +19935,88 @@ function collectRequireTokens(ast) {
   };
 }
 
+// src/plugins/utils/invalidateEntry.ts
+init_esm_shims();
+import fs9 from "fs";
+import process6 from "process";
+import path15 from "pathe";
+var watchedCssExts = new Set(supportedCssLangs.map((ext2) => `.${ext2}`));
+var configSuffixes = configExtensions.map((ext2) => `.${ext2}`);
+var sidecarSuffixes = [...configSuffixes, ...watchedCssExts];
+var supportsRecursiveWatch = process6.platform === "darwin" || process6.platform === "win32";
+async function invalidateEntryForSidecar(filePath) {
+  const configSuffix = configSuffixes.find((suffix) => filePath.endsWith(suffix));
+  const ext2 = path15.extname(filePath);
+  let scriptBasePath;
+  if (configSuffix) {
+    scriptBasePath = filePath.slice(0, -configSuffix.length);
+  } else if (ext2 && watchedCssExts.has(ext2)) {
+    scriptBasePath = filePath.slice(0, -ext2.length);
+  }
+  if (!scriptBasePath) {
+    return;
+  }
+  const { path: scriptPath } = await findJsEntry(scriptBasePath);
+  if (!scriptPath) {
+    return;
+  }
+  await touch(scriptPath);
+}
+function ensureSidecarWatcher(ctx, rootDir) {
+  if (!ctx.configService.isDev || !rootDir || process6.env.VITEST === "true" || process6.env.NODE_ENV === "test") {
+    return;
+  }
+  const { sidecarWatcherMap } = ctx.runtimeState.watcher;
+  const absRoot = path15.normalize(rootDir);
+  if (!fs9.existsSync(absRoot)) {
+    return;
+  }
+  if (sidecarWatcherMap.has(absRoot)) {
+    return;
+  }
+  const handleSidecarChange = (filePath) => {
+    if (!isSidecarFile(filePath)) {
+      return;
+    }
+    void invalidateEntryForSidecar(filePath);
+  };
+  if (supportsRecursiveWatch) {
+    const watcher2 = fs9.watch(absRoot, { recursive: true }, (_event, filename) => {
+      if (!filename) {
+        return;
+      }
+      const resolved = path15.join(absRoot, filename.toString());
+      handleSidecarChange(resolved);
+    });
+    sidecarWatcherMap.set(absRoot, {
+      close: async () => {
+        watcher2.close();
+      }
+    });
+    return;
+  }
+  const patterns = [
+    ...configExtensions.map((ext2) => path15.join(absRoot, `**/*.${ext2}`)),
+    ...supportedCssLangs.map((ext2) => path15.join(absRoot, `**/*.${ext2}`))
+  ];
+  const watcher = esm_default.watch(patterns, {
+    ignoreInitial: true,
+    persistent: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 100,
+      pollInterval: 20
+    }
+  });
+  watcher.on("add", handleSidecarChange);
+  watcher.on("unlink", handleSidecarChange);
+  sidecarWatcherMap.set(absRoot, {
+    close: () => watcher.close()
+  });
+}
+function isSidecarFile(filePath) {
+  return sidecarSuffixes.some((suffix) => filePath.endsWith(suffix));
+}
+
 // src/plugins/utils/parse.ts
 init_esm_shims();
 function parseRequest(id) {
@@ -19958,10 +20079,17 @@ function createCoreLifecyclePlugin(state) {
     enforce: "pre",
     buildStart() {
       loadedEntrySet.clear();
+      if (configService.isDev) {
+        const rootDir = subPackageMeta ? path16.resolve(configService.absoluteSrcRoot, subPackageMeta.subPackage.root) : configService.absoluteSrcRoot;
+        ensureSidecarWatcher(ctx, rootDir);
+      }
     },
-    watchChange(id, change) {
+    async watchChange(id, change) {
       const relativeSrc = configService.relativeAbsoluteSrcRoot(id);
       const relativeCwd = configService.relativeCwd(id);
+      if (change.event === "create" || change.event === "delete") {
+        await invalidateEntryForSidecar(id);
+      }
       if (!subPackageMeta) {
         if (relativeSrc === "app.json" || relativeCwd === "project.config.json" || relativeCwd === "project.private.config.json") {
           scanService.markDirty();
@@ -19984,7 +20112,7 @@ function createCoreLifecyclePlugin(state) {
       let scannedInput;
       if (subPackageMeta) {
         scannedInput = subPackageMeta.entries.reduce((acc, entry) => {
-          acc[entry] = path15.resolve(configService.absoluteSrcRoot, entry);
+          acc[entry] = path16.resolve(configService.absoluteSrcRoot, entry);
           return acc;
         }, {});
       } else {
@@ -20035,8 +20163,8 @@ function createCoreLifecyclePlugin(state) {
         if (parsed.query.wxss) {
           const realPath = getCssRealPath(parsed);
           this.addWatchFile(realPath);
-          if (await fs9.exists(realPath)) {
-            const css2 = await fs9.readFile(realPath, "utf8");
+          if (await fs10.exists(realPath)) {
+            const css2 = await fs10.readFile(realPath, "utf8");
             return { code: css2 };
           }
         }
@@ -20107,7 +20235,7 @@ function createRequireAnalysisPlugin(state) {
         return;
       }
       for (const requireModule of requireTokens) {
-        const absPath = path15.resolve(path15.dirname(moduleInfo.id), requireModule.value);
+        const absPath = path16.resolve(path16.dirname(moduleInfo.id), requireModule.value);
         const resolved = await this.resolve(absPath, moduleInfo.id);
         if (!resolved) {
           continue;
@@ -20460,8 +20588,8 @@ function createEnvSynchronizer({ configService }) {
 init_esm_shims();
 import { createHash } from "crypto";
 import { removeExtension as removeExtension2 } from "@weapp-core/shared";
-import fs10 from "fs-extra";
-import path16 from "pathe";
+import fs11 from "fs-extra";
+import path17 from "pathe";
 function workers(ctx) {
   if (!ctx.scanService.workersDir) {
     return [];
@@ -20489,23 +20617,23 @@ function createWorkerBuildPlugin(ctx) {
       options.chunkFileNames = (chunkInfo) => {
         const workersDir = scanService.workersDir ?? "";
         if (chunkInfo.isDynamicEntry) {
-          return path16.join(workersDir, "[name].js");
+          return path17.join(workersDir, "[name].js");
         }
         const sourceId = chunkInfo.facadeModuleId ?? chunkInfo.moduleIds[0];
         const hashBase = typeof sourceId === "string" ? configService.relativeCwd(sourceId) : chunkInfo.name;
         const stableHash = createHash("sha256").update(hashBase).digest("base64url").slice(0, 8);
-        return path16.join(workersDir, `${chunkInfo.name}-${stableHash}.js`);
+        return path17.join(workersDir, `${chunkInfo.name}-${stableHash}.js`);
       };
     }
   };
 }
 async function resolveWorkerEntry(ctx, entry) {
   const { configService, scanService } = ctx;
-  const relativeEntryPath = path16.join(scanService.workersDir, entry);
+  const relativeEntryPath = path17.join(scanService.workersDir, entry);
   const key = removeExtension2(relativeEntryPath);
-  const absoluteEntry = path16.resolve(configService.absoluteSrcRoot, relativeEntryPath);
+  const absoluteEntry = path17.resolve(configService.absoluteSrcRoot, relativeEntryPath);
   if (isJsOrTs(entry)) {
-    const exists = await fs10.exists(absoluteEntry);
+    const exists = await fs11.exists(absoluteEntry);
     if (!exists) {
       logger_default.warn(`\u5F15\u7528 worker: \`${configService.relativeCwd(relativeEntryPath)}\` \u4E0D\u5B58\u5728!`);
       return { key };
@@ -20523,8 +20651,8 @@ async function resolveWorkerEntry(ctx, entry) {
 // src/plugins/wxs.ts
 init_esm_shims();
 import { removeExtension as removeExtension3 } from "@weapp-core/shared";
-import fs11 from "fs-extra";
-import path17 from "pathe";
+import fs12 from "fs-extra";
+import path18 from "pathe";
 var wxsCodeCache = new LRUCache({
   max: 512
 });
@@ -20569,7 +20697,7 @@ async function handleWxsDeps(state, deps, absPath) {
       if (!jsExtensions.includes(dep.attrs.lang) && !arr) {
         return;
       }
-      const wxsPath = path17.resolve(path17.dirname(absPath), dep.value);
+      const wxsPath = path18.resolve(path18.dirname(absPath), dep.value);
       await transformWxsFile.call(this, state, wxsPath);
     })
   );
@@ -20578,7 +20706,7 @@ async function transformWxsFile(state, wxsPath) {
   const { ctx } = state;
   const { configService } = ctx;
   this.addWatchFile(wxsPath);
-  if (!await fs11.exists(wxsPath)) {
+  if (!await fs12.exists(wxsPath)) {
     return;
   }
   const suffixMatch = wxsPath.match(/\.wxs(\.[jt]s)?$/);
@@ -20586,7 +20714,7 @@ async function transformWxsFile(state, wxsPath) {
   if (suffixMatch) {
     isRaw = !suffixMatch[1];
   }
-  const rawCode = await fs11.readFile(wxsPath, "utf8");
+  const rawCode = await fs12.readFile(wxsPath, "utf8");
   let code = wxsCodeCache.get(rawCode);
   if (code === void 0) {
     const { result, importees } = transformWxsCode(rawCode, {
@@ -20595,13 +20723,13 @@ async function transformWxsFile(state, wxsPath) {
     if (typeof result?.code === "string") {
       code = result.code;
     }
-    const dirname5 = path17.dirname(wxsPath);
+    const dirname5 = path18.dirname(wxsPath);
     await Promise.all(
       importees.map(({ source }) => {
         return transformWxsFile.call(
           this,
           state,
-          path17.resolve(dirname5, source)
+          path18.resolve(dirname5, source)
         );
       })
     );
@@ -20669,7 +20797,7 @@ function createConfigService(ctx) {
   let packageManager = configState.packageManager;
   let options = configState.options;
   const oxcRuntimeInfo = getPackageInfoSync("@oxc-project/runtime");
-  const oxcRuntimeHelpersRoot = oxcRuntimeInfo ? path18.resolve(oxcRuntimeInfo.rootPath, "src/helpers/esm") : void 0;
+  const oxcRuntimeHelpersRoot = oxcRuntimeInfo ? path19.resolve(oxcRuntimeInfo.rootPath, "src/helpers/esm") : void 0;
   const NULL_BYTE = "\0";
   const OXC_RUNTIME_HELPER_ALIAS = new RegExp(`^(?:${NULL_BYTE})?@oxc-project(?:/|\\+)runtime(?:@[^/]+)?/helpers/(.+)\\.js$`);
   const FALLBACK_HELPER_PREFIX = `${NULL_BYTE}weapp-vite:oxc-helper:`;
@@ -20751,7 +20879,7 @@ export default _objectSpread2;`
         }
         return null;
       }
-      return path18.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
+      return path19.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
     },
     async load(id) {
       if (id.startsWith(FALLBACK_HELPER_PREFIX)) {
@@ -20765,10 +20893,10 @@ export default _objectSpread2;`
       const helperName = getOxcHelperName(id);
       if (helperName) {
         if (oxcRuntimeHelpersRoot) {
-          const helperPath = id.startsWith(NULL_BYTE) ? path18.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`) : id;
-          if (await fs12.pathExists(helperPath)) {
+          const helperPath = id.startsWith(NULL_BYTE) ? path19.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`) : id;
+          if (await fs13.pathExists(helperPath)) {
             console.warn("[weapp-vite] resolving oxc helper via Rolldown plugin:", helperName);
-            return fs12.readFile(helperPath, "utf8");
+            return fs13.readFile(helperPath, "utf8");
           }
         }
         const fallback = fallbackHelpers[helperName];
@@ -20837,17 +20965,17 @@ export default _objectSpread2;`
     if (!mpDistRoot) {
       throw new Error("\u8BF7\u5728 `project.config.json` \u91CC\u8BBE\u7F6E `miniprogramRoot`, \u6BD4\u5982\u53EF\u4EE5\u8BBE\u7F6E\u4E3A `dist/` ");
     }
-    const packageJsonPath = path18.resolve(cwd, "package.json");
+    const packageJsonPath = path19.resolve(cwd, "package.json");
     let packageJson = {};
-    if (await fs12.exists(packageJsonPath)) {
-      const localPackageJson = await fs12.readJson(packageJsonPath, {
+    if (await fs13.exists(packageJsonPath)) {
+      const localPackageJson = await fs13.readJson(packageJsonPath, {
         throws: false
       }) || {};
       packageJson = localPackageJson;
     }
     let resolvedConfigFile = configFile;
-    if (resolvedConfigFile && !path18.isAbsolute(resolvedConfigFile)) {
-      resolvedConfigFile = path18.resolve(cwd, resolvedConfigFile);
+    if (resolvedConfigFile && !path19.isAbsolute(resolvedConfigFile)) {
+      resolvedConfigFile = path19.resolve(cwd, resolvedConfigFile);
     }
     const loaded = await loadConfigFromFile({
       command: isDev ? "serve" : "build",
@@ -20857,7 +20985,7 @@ export default _objectSpread2;`
     const srcRoot = loadedConfig?.weapp?.srcRoot ?? "";
     function relativeSrcRoot(p) {
       if (srcRoot) {
-        return path18.relative(srcRoot, p);
+        return path19.relative(srcRoot, p);
       }
       return p;
     }
@@ -20917,7 +21045,7 @@ export default _objectSpread2;`
           }
           const helperName = getOxcHelperName(source);
           if (helperName) {
-            return path18.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
+            return path19.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
           }
           return null;
         },
@@ -20929,9 +21057,9 @@ export default _objectSpread2;`
           if (!helperName) {
             return null;
           }
-          const helperPath = path18.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
+          const helperPath = path19.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
           console.warn("[weapp-vite] resolving oxc helper via Vite plugin:", helperName);
-          return fs12.readFile(helperPath, "utf8");
+          return fs13.readFile(helperPath, "utf8");
         }
       });
     }
@@ -20958,7 +21086,7 @@ export default _objectSpread2;`
     };
   }
   async function load(optionsInput) {
-    const defaultCwd = process6.cwd();
+    const defaultCwd = process7.cwd();
     const input = defu3(optionsInput, {
       cwd: defaultCwd,
       isDev: false,
@@ -21054,9 +21182,9 @@ export default _objectSpread2;`
             watch: {
               exclude: [
                 ...defaultExcluded,
-                options.mpDistRoot ? path18.join(options.cwd, options.mpDistRoot, "**") : path18.join(options.cwd, "dist", "**")
+                options.mpDistRoot ? path19.join(options.cwd, options.mpDistRoot, "**") : path19.join(options.cwd, "dist", "**")
               ],
-              include: [path18.join(options.cwd, options.srcRoot, "**")]
+              include: [path19.join(options.cwd, options.srcRoot, "**")]
             },
             minify: false,
             emptyOutDir: false,
@@ -21143,7 +21271,7 @@ export default _objectSpread2;`
       return options.mpDistRoot;
     },
     get outDir() {
-      return path18.resolve(options.cwd, options.mpDistRoot ?? "");
+      return path19.resolve(options.cwd, options.mpDistRoot ?? "");
     },
     get currentSubPackageRoot() {
       return options.currentSubPackageRoot;
@@ -21168,11 +21296,11 @@ export default _objectSpread2;`
     },
     get absolutePluginRoot() {
       if (options.config.weapp?.pluginRoot) {
-        return path18.resolve(options.cwd, options.config.weapp.pluginRoot);
+        return path19.resolve(options.cwd, options.config.weapp.pluginRoot);
       }
     },
     get absoluteSrcRoot() {
-      return path18.resolve(options.cwd, options.srcRoot);
+      return path19.resolve(options.cwd, options.srcRoot);
     },
     get mode() {
       return options.mode;
@@ -21184,13 +21312,13 @@ export default _objectSpread2;`
       return options.platform;
     },
     relativeCwd(p) {
-      return path18.relative(options.cwd, p);
+      return path19.relative(options.cwd, p);
     },
     relativeSrcRoot(p) {
       return options.relativeSrcRoot(p);
     },
     relativeAbsoluteSrcRoot(p) {
-      return path18.relative(path18.resolve(options.cwd, options.srcRoot), p);
+      return path19.relative(path19.resolve(options.cwd, options.srcRoot), p);
     }
   };
 }
@@ -21205,7 +21333,7 @@ function createConfigServicePlugin(ctx) {
 // src/runtime/jsonPlugin.ts
 init_esm_shims();
 import { parse as parseJson2 } from "comment-json";
-import fs13 from "fs-extra";
+import fs14 from "fs-extra";
 import { bundleRequire } from "rolldown-require";
 function parseCommentJson(json) {
   return parseJson2(json, void 0, true);
@@ -21237,7 +21365,7 @@ function createJsonService(ctx) {
         });
         resultJson = typeof mod.default === "function" ? await mod.default(ctx) : mod.default;
       } else {
-        resultJson = parseCommentJson(await fs13.readFile(filepath, "utf8"));
+        resultJson = parseCommentJson(await fs14.readFile(filepath, "utf8"));
       }
       cache2.set(filepath, resultJson);
       return resultJson;
@@ -21270,14 +21398,14 @@ function createJsonServicePlugin(ctx) {
 init_esm_shims();
 import { isBuiltin } from "module";
 import { defu as defu4, isObject as isObject8, objectHash as objectHash2 } from "@weapp-core/shared";
-import fs14 from "fs-extra";
-import path19 from "pathe";
+import fs15 from "fs-extra";
+import path20 from "pathe";
 function createNpmService(ctx) {
   function getDependenciesCacheFilePath(key = "/") {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before generating npm cache path");
     }
-    return path19.resolve(ctx.configService.cwd, `node_modules/weapp-vite/.cache/${key.replaceAll("/", "-")}.json`);
+    return path20.resolve(ctx.configService.cwd, `node_modules/weapp-vite/.cache/${key.replaceAll("/", "-")}.json`);
   }
   function dependenciesCacheHash() {
     if (!ctx.configService) {
@@ -21289,22 +21417,22 @@ function createNpmService(ctx) {
     return Reflect.has(pkg, "miniprogram") && typeof pkg.miniprogram === "string";
   }
   async function shouldSkipBuild(outDir, isOutdated) {
-    return !isOutdated && await fs14.exists(outDir);
+    return !isOutdated && await fs15.exists(outDir);
   }
   async function writeDependenciesCache(root) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before writing npm cache");
     }
     if (ctx.configService.weappViteConfig?.npm?.cache) {
-      await fs14.outputJSON(getDependenciesCacheFilePath(root), {
+      await fs15.outputJSON(getDependenciesCacheFilePath(root), {
         hash: dependenciesCacheHash()
       });
     }
   }
   async function readDependenciesCache(root) {
     const cachePath = getDependenciesCacheFilePath(root);
-    if (await fs14.exists(cachePath)) {
-      return await fs14.readJson(cachePath, { throws: false });
+    if (await fs15.exists(cachePath)) {
+      return await fs15.readJson(cachePath, { throws: false });
     }
   }
   async function checkDependenciesCacheOutdate(root) {
@@ -21357,7 +21485,7 @@ function createNpmService(ctx) {
     }
   }
   async function copyBuild({ from, to }) {
-    await fs14.copy(
+    await fs15.copy(
       from,
       to
     );
@@ -21370,14 +21498,14 @@ function createNpmService(ctx) {
     const { packageJson: targetJson, rootPath } = packageInfo;
     const dependencies = targetJson.dependencies ?? {};
     const keys = Object.keys(dependencies);
-    const destOutDir = path19.resolve(outDir, dep);
+    const destOutDir = path20.resolve(outDir, dep);
     if (await shouldSkipBuild(destOutDir, isDependenciesCacheOutdate)) {
       logger_default.info(`[npm] \u4F9D\u8D56 \`${dep}\` \u672A\u53D1\u751F\u53D8\u5316\uFF0C\u8DF3\u8FC7\u5904\u7406!`);
       return;
     }
     if (isMiniprogramPackage(targetJson)) {
       await copyBuild({
-        from: path19.resolve(
+        from: path20.resolve(
           rootPath,
           targetJson.miniprogram
         ),
@@ -21449,10 +21577,10 @@ function createNpmService(ctx) {
     debug?.("buildNpm start");
     const packNpmRelationList = getPackNpmRelationList();
     const [mainRelation, ...subRelations] = packNpmRelationList;
-    const packageJsonPath = path19.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
-    if (await fs14.exists(packageJsonPath)) {
-      const pkgJson = await fs14.readJson(packageJsonPath);
-      const outDir = path19.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, "miniprogram_npm");
+    const packageJsonPath = path20.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
+    if (await fs15.exists(packageJsonPath)) {
+      const pkgJson = await fs15.readJson(packageJsonPath);
+      const outDir = path20.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, "miniprogram_npm");
       if (pkgJson.dependencies) {
         const dependencies = Object.keys(pkgJson.dependencies);
         if (dependencies.length > 0) {
@@ -21471,7 +21599,7 @@ function createNpmService(ctx) {
           const targetDirs = [
             ...subRelations.map((x) => {
               return {
-                npmDistDir: path19.resolve(ctx.configService.cwd, x.miniprogramNpmDistDir, "miniprogram_npm")
+                npmDistDir: path20.resolve(ctx.configService.cwd, x.miniprogramNpmDistDir, "miniprogram_npm")
               };
             }),
             ...[...ctx.scanService.independentSubPackageMap.values()].map((x) => {
@@ -21479,19 +21607,19 @@ function createNpmService(ctx) {
               return {
                 root: x.subPackage.root,
                 dependencies: dependencies2,
-                npmDistDir: path19.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, x.subPackage.root, "miniprogram_npm")
+                npmDistDir: path20.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, x.subPackage.root, "miniprogram_npm")
               };
             })
           ];
           await Promise.all(targetDirs.map(async (x) => {
             if (x.root) {
               const isDependenciesCacheOutdate2 = await checkDependenciesCacheOutdate(x.root);
-              if (isDependenciesCacheOutdate2 || !await fs14.exists(x.npmDistDir)) {
-                await fs14.copy(outDir, x.npmDistDir, {
+              if (isDependenciesCacheOutdate2 || !await fs15.exists(x.npmDistDir)) {
+                await fs15.copy(outDir, x.npmDistDir, {
                   overwrite: true,
                   filter: (src) => {
                     if (Array.isArray(x.dependencies)) {
-                      const relPath = path19.relative(outDir, src);
+                      const relPath = path20.relative(outDir, src);
                       if (relPath === "") {
                         return true;
                       }
@@ -21503,11 +21631,11 @@ function createNpmService(ctx) {
               }
               await writeDependenciesCache(x.root);
             } else {
-              await fs14.copy(outDir, x.npmDistDir, {
+              await fs15.copy(outDir, x.npmDistDir, {
                 overwrite: true,
                 filter: (src) => {
                   if (Array.isArray(x.dependencies)) {
-                    const relPath = path19.relative(outDir, src);
+                    const relPath = path20.relative(outDir, src);
                     if (relPath === "") {
                       return true;
                     }
@@ -21550,7 +21678,7 @@ function createNpmServicePlugin(ctx) {
 
 // src/runtime/runtimeState.ts
 init_esm_shims();
-import process7 from "process";
+import process8 from "process";
 
 // ../../node_modules/.pnpm/p-queue@9.0.0/node_modules/p-queue/dist/index.js
 init_esm_shims();
@@ -22261,7 +22389,7 @@ init_esm_shims();
 // src/cache/file.ts
 init_esm_shims();
 import { createHash as createHash2 } from "crypto";
-import fs15 from "fs-extra";
+import fs16 from "fs-extra";
 function createSignature(content) {
   return createHash2("sha1").update(content).digest("hex");
 }
@@ -22289,7 +22417,7 @@ var FileCache = class {
   async isInvalidate(id, options) {
     let mtimeMs;
     try {
-      const stat6 = await fs15.stat(id);
+      const stat6 = await fs16.stat(id);
       mtimeMs = stat6.mtimeMs;
     } catch (error) {
       if (error && error.code === "ENOENT") {
@@ -22343,7 +22471,7 @@ function createDefaultLoadConfigResult() {
     outputExtensions: getOutputExtensions("weapp"),
     packageJson: {},
     relativeSrcRoot: (p) => p,
-    cwd: process7.cwd(),
+    cwd: process8.cwd(),
     isDev: false,
     mode: "development",
     projectConfig: {},
@@ -22382,7 +22510,8 @@ function createRuntimeState() {
       cache: new FileCache()
     },
     watcher: {
-      rollupWatcherMap: /* @__PURE__ */ new Map()
+      rollupWatcherMap: /* @__PURE__ */ new Map(),
+      sidecarWatcherMap: /* @__PURE__ */ new Map()
     },
     wxml: {
       depsMap: /* @__PURE__ */ new Map(),
@@ -22408,7 +22537,7 @@ function createRuntimeState() {
 // src/runtime/scanPlugin.ts
 init_esm_shims();
 import { isObject as isObject9, removeExtensionDeep as removeExtensionDeep5 } from "@weapp-core/shared";
-import path20 from "pathe";
+import path21 from "pathe";
 function resolveSubPackageEntries(subPackage) {
   const entries = [];
   const root = subPackage.root ?? "";
@@ -22432,11 +22561,11 @@ function createScanService(ctx) {
       return scanState.appEntry;
     }
     const appDirname = ctx.configService.absoluteSrcRoot;
-    const appBasename = path20.resolve(appDirname, "app");
+    const appBasename = path21.resolve(appDirname, "app");
     const { path: appConfigFile } = await findJsonEntry(appBasename);
     const { path: appEntryPath } = await findJsEntry(appBasename);
     if (ctx.configService.absolutePluginRoot) {
-      const pluginBasename = path20.resolve(ctx.configService.absolutePluginRoot, "plugin");
+      const pluginBasename = path21.resolve(ctx.configService.absolutePluginRoot, "plugin");
       const { path: pluginConfigFile } = await findJsonEntry(pluginBasename);
       if (pluginConfigFile) {
         const pluginConfig = await ctx.jsonService.read(pluginConfigFile);
@@ -22455,14 +22584,14 @@ function createScanService(ctx) {
         scanState.appEntry = resolvedAppEntry;
         const { sitemapLocation = "sitemap.json", themeLocation = "theme.json" } = config;
         if (sitemapLocation) {
-          const { path: sitemapJsonPath } = await findJsonEntry(path20.resolve(appDirname, sitemapLocation));
+          const { path: sitemapJsonPath } = await findJsonEntry(path21.resolve(appDirname, sitemapLocation));
           if (sitemapJsonPath) {
             resolvedAppEntry.sitemapJsonPath = sitemapJsonPath;
             resolvedAppEntry.sitemapJson = await ctx.jsonService.read(sitemapJsonPath);
           }
         }
         if (themeLocation) {
-          const { path: themeJsonPath } = await findJsonEntry(path20.resolve(appDirname, themeLocation));
+          const { path: themeJsonPath } = await findJsonEntry(path21.resolve(appDirname, themeLocation));
           if (themeJsonPath) {
             resolvedAppEntry.themeJsonPath = themeJsonPath;
             resolvedAppEntry.themeJson = await ctx.jsonService.read(themeJsonPath);
@@ -22590,9 +22719,10 @@ function createScanServicePlugin(ctx) {
 // src/runtime/watcherPlugin.ts
 init_esm_shims();
 function createWatcherService(ctx) {
-  const { rollupWatcherMap } = ctx.runtimeState.watcher;
+  const { rollupWatcherMap, sidecarWatcherMap } = ctx.runtimeState.watcher;
   return {
     rollupWatcherMap,
+    sidecarWatcherMap,
     getRollupWatcher(root = "/") {
       return rollupWatcherMap.get(root);
     },
@@ -22606,6 +22736,11 @@ function createWatcherService(ctx) {
         watcher.close();
       });
       rollupWatcherMap.clear();
+      sidecarWatcherMap.forEach((watcher) => {
+        Promise.resolve(watcher.close()).catch(() => {
+        });
+      });
+      sidecarWatcherMap.clear();
     },
     close(root = "/") {
       const watcher = rollupWatcherMap.get(root);
@@ -22613,6 +22748,12 @@ function createWatcherService(ctx) {
         watcher.close();
         rollupWatcherMap.delete(root);
       }
+      const sidecarWatcher = sidecarWatcherMap.get(root);
+      if (sidecarWatcher) {
+        Promise.resolve(sidecarWatcher.close()).catch(() => {
+        });
+        sidecarWatcherMap.delete(root);
+      }
     }
   };
 }
@@ -22634,8 +22775,8 @@ function createWatcherServicePlugin(ctx) {
 // src/runtime/wxmlPlugin.ts
 init_esm_shims();
 import { removeExtensionDeep as removeExtensionDeep6 } from "@weapp-core/shared";
-import fs16 from "fs-extra";
-import path21 from "pathe";
+import fs17 from "fs-extra";
+import path22 from "pathe";
 
 // src/wxml/index.ts
 init_esm_shims();
@@ -25332,9 +25473,9 @@ function createWxmlService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning wxml");
     }
-    if (await fs16.exists(filepath)) {
-      const dirname5 = path21.dirname(filepath);
-      const wxml = await fs16.readFile(filepath, "utf8");
+    if (await fs17.exists(filepath)) {
+      const dirname5 = path22.dirname(filepath);
+      const wxml = await fs17.readFile(filepath, "utf8");
       const shouldRescan = await cache2.isInvalidate(filepath, { content: wxml });
       if (!shouldRescan) {
         const cached = cache2.get(filepath);
@@ -25350,9 +25491,9 @@ function createWxmlService(ctx) {
         filepath,
         res.deps.filter((x) => isImportTag(x.tagName) && isTemplate(x.value)).map((x) => {
           if (x.value.startsWith("/")) {
-            return path21.resolve(ctx.configService.absoluteSrcRoot, x.value.slice(1));
+            return path22.resolve(ctx.configService.absoluteSrcRoot, x.value.slice(1));
           } else {
-            return path21.resolve(dirname5, x.value);
+            return path22.resolve(dirname5, x.value);
           }
         })
       );