weapp-vite 6.7.4 → 6.7.5

package/dist/{chunk-MKXI5POD.mjs → chunk-RJ6CSAFO.mjs}

@@ -14,16 +14,19 @@ import {
   templateExtensions,
   touch,
   vueExtensions
-} from "./chunk-3ULSPLMB.mjs";
+} from "./chunk-Z53O6PMZ.mjs";
+import {
+  applyWeappViteHostMeta
+} from "./chunk-BGBLJUWD.mjs";
 import {
   configureLogger,
   default as default2
-} from "./chunk-VZEM2LX3.mjs";
+} from "./chunk-XIEFUUA5.mjs";
 import {
   __commonJS,
   __toESM,
   init_esm_shims
-} from "./chunk-BQM4WPKJ.mjs";
+} from "./chunk-QD76G22N.mjs";
 
 // ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/debug.js
 var require_debug = __commonJS({
@@ -2547,7 +2550,7 @@ function extractPropertiesObject(node) {
   }
   return propMap;
 }
-function resolveOptionsObjectExpression(path81, node) {
+function resolveOptionsObjectExpression(path82, node) {
   if (!node) {
     return void 0;
   }
@@ -2555,7 +2558,7 @@ function resolveOptionsObjectExpression(path81, node) {
     return node;
   }
   if (node.type === "Identifier") {
-    const binding = path81.scope.getBinding(node.name);
+    const binding = path82.scope.getBinding(node.name);
     const bindingPath = binding?.path;
     if (bindingPath?.isVariableDeclarator()) {
       const init = bindingPath.node.init;
@@ -2566,7 +2569,7 @@ function resolveOptionsObjectExpression(path81, node) {
     return void 0;
   }
   if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression") {
-    return resolveOptionsObjectExpression(path81, node.expression);
+    return resolveOptionsObjectExpression(path82, node.expression);
   }
   return void 0;
 }
@@ -2590,12 +2593,12 @@ function extractComponentProps(code) {
   const ast = parse(code, BABEL_TS_MODULE_PARSER_OPTIONS);
   let props = /* @__PURE__ */ new Map();
   traverse(ast, {
-    CallExpression(path81) {
+    CallExpression(path82) {
       if (props.size > 0) {
         return;
       }
-      const [options] = path81.node.arguments;
-      const optionsObject = resolveOptionsObjectExpression(path81, options);
+      const [options] = path82.node.arguments;
+      const optionsObject = resolveOptionsObjectExpression(path82, options);
       if (!optionsObject) {
         return;
       }
@@ -2766,12 +2769,12 @@ function extractComponentPropsFromDts(code) {
     errorRecovery: true
   });
   traverse(ast, {
-    TSInterfaceDeclaration(path81) {
+    TSInterfaceDeclaration(path82) {
       if (props.size > 0) {
-        path81.stop();
+        path82.stop();
         return;
       }
-      for (const member of path81.node.body.body) {
+      for (const member of path82.node.body.body) {
         if (member.type !== "TSPropertySignature") {
           continue;
         }
@@ -2782,22 +2785,22 @@ function extractComponentPropsFromDts(code) {
         const typeNode = unwrapTypeAnnotation(member.typeAnnotation);
         if (typeNode?.type === "TSTypeLiteral") {
           props = extractFromPropertiesTypeLiteral(typeNode);
-          path81.stop();
+          path82.stop();
           return;
         }
       }
-      const extracted = extractFromPropsInterfaceMembers(path81.node);
+      const extracted = extractFromPropsInterfaceMembers(path82.node);
       if (extracted.size > 0) {
         props = extracted;
-        path81.stop();
+        path82.stop();
       }
     },
-    ClassDeclaration(path81) {
+    ClassDeclaration(path82) {
       if (props.size > 0) {
-        path81.stop();
+        path82.stop();
         return;
       }
-      for (const member of path81.node.body.body) {
+      for (const member of path82.node.body.body) {
         if (member.type !== "ClassProperty" && member.type !== "ClassAccessorProperty") {
           continue;
         }
@@ -2808,7 +2811,7 @@ function extractComponentPropsFromDts(code) {
         const typeNode = unwrapTypeAnnotation(member.typeAnnotation);
         if (typeNode?.type === "TSTypeLiteral") {
           props = extractFromPropertiesTypeLiteral(typeNode);
-          path81.stop();
+          path82.stop();
           return;
         }
       }
@@ -7160,28 +7163,6 @@ function isCSSRequest(request) {
 function isRegexp(value) {
   return Object.prototype.toString.call(value) === "[object RegExp]";
 }
-function regExpTest(arr, str, options) {
-  if (!Array.isArray(arr)) {
-    throw new TypeError("paramater 'arr' should be an Array of Regexp | String");
-  }
-  for (const item of arr) {
-    if (typeof item === "string") {
-      if (options?.exact) {
-        if (str === item) {
-          return true;
-        }
-      } else if (str.includes(item)) {
-        return true;
-      }
-    } else if (isRegexp(item)) {
-      item.lastIndex = 0;
-      if (item.test(str)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
 
 // src/utils/resolvedId.ts
 init_esm_shims();
@@ -8464,7 +8445,7 @@ async function updateCandidateFromFile(ctx, stateCandidates, filePath, event, ma
   if (!ctx.configService) {
     return false;
   }
-  if (event === "rename") {
+  if (event === "rename" || event === "create" || event === "delete") {
     markNeedsFullRescan?.();
     return true;
   }
@@ -14404,17 +14385,17 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path81 = input;
+  let path82 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex !== -1) {
-    path81 = input.slice(0, fragmentIndex);
+    path82 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path81) {
+    if (!path82) {
       return fragment;
     }
   }
-  const [s0, ...s] = path81.split("?");
+  const [s0, ...s] = path82.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -14442,8 +14423,8 @@ import path22, { dirname } from "path";
 import v8 from "v8";
 import { format, inspect } from "util";
 var BUILTIN_MODULES = new Set(builtinModules);
-function normalizeSlash(path81) {
-  return path81.replace(/\\/g, "/");
+function normalizeSlash(path82) {
+  return path82.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -14556,8 +14537,8 @@ codes.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path81, base, message) => {
-    return `Invalid package config ${path81}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path82, base, message) => {
+    return `Invalid package config ${path82}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -14589,8 +14570,8 @@ codes.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path81, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path81}' imported from ${base}`;
+  (path82, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path82}' imported from ${base}`;
   },
   Error
 );
@@ -14641,8 +14622,8 @@ codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path81) => {
-    return `Unknown file extension "${extension}" for ${path81}`;
+  (extension, path82) => {
+    return `Unknown file extension "${extension}" for ${path82}`;
   },
   TypeError
 );
@@ -15013,9 +14994,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path81) {
+function tryStatSync(path82) {
   try {
-    return statSync(path81);
+    return statSync(path82);
   } catch {
   }
 }
@@ -15934,7 +15915,7 @@ function findUpSync(name, {
     directory = path23.dirname(directory);
   }
 }
-function _resolve2(path81, options = {}) {
+function _resolve2(path82, options = {}) {
   if (options.platform === "auto" || !options.platform)
     options.platform = process3.platform === "win32" ? "win32" : "posix";
   if (process3.versions.pnp) {
@@ -15943,11 +15924,11 @@ function _resolve2(path81, options = {}) {
       paths.push(process3.cwd());
     const targetRequire = createRequire5(import.meta.url);
     try {
-      return targetRequire.resolve(path81, { paths });
+      return targetRequire.resolve(path82, { paths });
     } catch {
     }
   }
-  const modulePath = resolvePathSync(path81, {
+  const modulePath = resolvePathSync(path82, {
     url: options.paths
   });
   if (options.platform === "win32")
@@ -16018,10 +15999,10 @@ var findUp = quansync2({
   async: findUp$1
 });
 var loadPackageJSON = quansync2(function* (cwd = process3.cwd()) {
-  const path81 = yield findUp("package.json", { cwd });
-  if (!path81 || !fs13.existsSync(path81))
+  const path82 = yield findUp("package.json", { cwd });
+  if (!path82 || !fs13.existsSync(path82))
     return null;
-  return JSON.parse(yield readFile(path81));
+  return JSON.parse(yield readFile(path82));
 });
 var loadPackageJSONSync = loadPackageJSON.sync;
 var isPackageListed = quansync2(function* (name, cwd) {
@@ -21380,44 +21361,44 @@ var optArgSync = (opt = {}) => optArgT(opt);
 init_esm_shims();
 import { parse as parse4, resolve } from "path";
 import { inspect as inspect2 } from "util";
-var pathArg = (path81, opt = {}) => {
-  const type = typeof path81;
+var pathArg = (path82, opt = {}) => {
+  const type = typeof path82;
   if (type !== "string") {
-    const ctor = path81 && type === "object" && path81.constructor;
-    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? inspect2(path81) : `type ${type} ${path81}`;
+    const ctor = path82 && type === "object" && path82.constructor;
+    const received = ctor && ctor.name ? `an instance of ${ctor.name}` : type === "object" ? inspect2(path82) : `type ${type} ${path82}`;
     const msg = `The "path" argument must be of type string. Received ${received}`;
     throw Object.assign(new TypeError(msg), {
-      path: path81,
+      path: path82,
       code: "ERR_INVALID_ARG_TYPE"
     });
   }
-  if (/\0/.test(path81)) {
+  if (/\0/.test(path82)) {
     const msg = "path must be a string without null bytes";
     throw Object.assign(new TypeError(msg), {
-      path: path81,
+      path: path82,
       code: "ERR_INVALID_ARG_VALUE"
     });
   }
-  path81 = resolve(path81);
-  const { root } = parse4(path81);
-  if (path81 === root && opt.preserveRoot !== false) {
+  path82 = resolve(path82);
+  const { root } = parse4(path82);
+  if (path82 === root && opt.preserveRoot !== false) {
     const msg = "refusing to remove root directory without preserveRoot:false";
     throw Object.assign(new Error(msg), {
-      path: path81,
+      path: path82,
       code: "ERR_PRESERVE_ROOT"
     });
   }
   if (process.platform === "win32") {
     const badWinChars = /[*|"<>?:]/;
-    const { root: root2 } = parse4(path81);
-    if (badWinChars.test(path81.substring(root2.length))) {
+    const { root: root2 } = parse4(path82);
+    if (badWinChars.test(path82.substring(root2.length))) {
       throw Object.assign(new Error("Illegal characters in path."), {
-        path: path81,
+        path: path82,
         code: "EINVAL"
       });
     }
   }
-  return path81;
+  return path82;
 };
 var path_arg_default = pathArg;
 
@@ -21432,11 +21413,11 @@ init_esm_shims();
 import { readdirSync as rdSync } from "fs";
 import fsPromises2 from "fs/promises";
 import { chmodSync, mkdirSync, renameSync, rmdirSync, rmSync, statSync as statSync2, lstatSync, unlinkSync } from "fs";
-var readdirSync = (path81) => rdSync(path81, { withFileTypes: true });
+var readdirSync = (path82) => rdSync(path82, { withFileTypes: true });
 var promises2 = {
   chmod: fsPromises2.chmod,
   mkdir: fsPromises2.mkdir,
-  readdir: (path81) => fsPromises2.readdir(path81, { withFileTypes: true }),
+  readdir: (path82) => fsPromises2.readdir(path82, { withFileTypes: true }),
   rename: fsPromises2.rename,
   rm: fsPromises2.rm,
   rmdir: fsPromises2.rmdir,
@@ -21451,10 +21432,10 @@ import { parse as parse5, resolve as resolve2 } from "path";
 // ../../node_modules/.pnpm/rimraf@6.1.3/node_modules/rimraf/dist/esm/readdir-or-error.js
 init_esm_shims();
 var { readdir } = promises2;
-var readdirOrError = (path81) => readdir(path81).catch((er) => er);
-var readdirOrErrorSync = (path81) => {
+var readdirOrError = (path82) => readdir(path82).catch((er) => er);
+var readdirOrErrorSync = (path82) => {
   try {
-    return readdirSync(path81);
+    return readdirSync(path82);
   } catch (er) {
     return er;
   }
@@ -21490,17 +21471,17 @@ var ignoreENOENTSync = (fn, rethrow) => {
 
 // ../../node_modules/.pnpm/rimraf@6.1.3/node_modules/rimraf/dist/esm/rimraf-posix.js
 var { lstat, rmdir, unlink } = promises2;
-var rimrafPosix = async (path81, opt) => {
+var rimrafPosix = async (path82, opt) => {
   opt?.signal?.throwIfAborted();
-  return await ignoreENOENT(lstat(path81).then((stat5) => rimrafPosixDir(path81, opt, stat5))) ?? true;
+  return await ignoreENOENT(lstat(path82).then((stat5) => rimrafPosixDir(path82, opt, stat5))) ?? true;
 };
-var rimrafPosixSync = (path81, opt) => {
+var rimrafPosixSync = (path82, opt) => {
   opt?.signal?.throwIfAborted();
-  return ignoreENOENTSync(() => rimrafPosixDirSync(path81, opt, lstatSync(path81))) ?? true;
+  return ignoreENOENTSync(() => rimrafPosixDirSync(path82, opt, lstatSync(path82))) ?? true;
 };
-var rimrafPosixDir = async (path81, opt, ent) => {
+var rimrafPosixDir = async (path82, opt, ent) => {
   opt?.signal?.throwIfAborted();
-  const entries = ent.isDirectory() ? await readdirOrError(path81) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path82) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -21510,28 +21491,28 @@ var rimrafPosixDir = async (path81, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path81, ent)) {
+    if (opt.filter && !await opt.filter(path82, ent)) {
       return false;
     }
-    await ignoreENOENT(unlink(path81));
+    await ignoreENOENT(unlink(path82));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(resolve2(path81, ent2.name), opt, ent2)))).every((v2) => v2 === true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafPosixDir(resolve2(path82, ent2.name), opt, ent2)))).every((v2) => v2 === true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path81 === parse5(path81).root) {
+  if (opt.preserveRoot === false && path82 === parse5(path82).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path81, ent)) {
+  if (opt.filter && !await opt.filter(path82, ent)) {
     return false;
   }
-  await ignoreENOENT(rmdir(path81));
+  await ignoreENOENT(rmdir(path82));
   return true;
 };
-var rimrafPosixDirSync = (path81, opt, ent) => {
+var rimrafPosixDirSync = (path82, opt, ent) => {
   opt?.signal?.throwIfAborted();
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path81) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path82) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -21541,27 +21522,27 @@ var rimrafPosixDirSync = (path81, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path81, ent)) {
+    if (opt.filter && !opt.filter(path82, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => unlinkSync(path81));
+    ignoreENOENTSync(() => unlinkSync(path82));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = resolve2(path81, ent2.name);
+    const p = resolve2(path82, ent2.name);
     removedAll = rimrafPosixDirSync(p, opt, ent2) && removedAll;
   }
-  if (opt.preserveRoot === false && path81 === parse5(path81).root) {
+  if (opt.preserveRoot === false && path82 === parse5(path82).root) {
     return false;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.filter && !opt.filter(path81, ent)) {
+  if (opt.filter && !opt.filter(path82, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => rmdirSync(path81));
+  ignoreENOENTSync(() => rmdirSync(path82));
   return true;
 };
 
@@ -21572,28 +21553,28 @@ import { parse as parse8, resolve as resolve5 } from "path";
 // ../../node_modules/.pnpm/rimraf@6.1.3/node_modules/rimraf/dist/esm/fix-eperm.js
 init_esm_shims();
 var { chmod } = promises2;
-var fixEPERM = (fn) => async (path81) => {
+var fixEPERM = (fn) => async (path82) => {
   try {
-    return void await ignoreENOENT(fn(path81));
+    return void await ignoreENOENT(fn(path82));
   } catch (er) {
     if (errorCode(er) === "EPERM") {
-      if (!await ignoreENOENT(chmod(path81, 438).then(() => true), er)) {
+      if (!await ignoreENOENT(chmod(path82, 438).then(() => true), er)) {
         return;
       }
-      return void await fn(path81);
+      return void await fn(path82);
     }
     throw er;
   }
 };
-var fixEPERMSync = (fn) => (path81) => {
+var fixEPERMSync = (fn) => (path82) => {
   try {
-    return void ignoreENOENTSync(() => fn(path81));
+    return void ignoreENOENTSync(() => fn(path82));
   } catch (er) {
     if (errorCode(er) === "EPERM") {
-      if (!ignoreENOENTSync(() => (chmodSync(path81, 438), true), er)) {
+      if (!ignoreENOENTSync(() => (chmodSync(path82, 438), true), er)) {
         return;
       }
-      return void fn(path81);
+      return void fn(path82);
     }
     throw er;
   }
@@ -21607,21 +21588,21 @@ var RATE = 1.2;
 var MAXRETRIES = 10;
 var codes2 = /* @__PURE__ */ new Set(["EMFILE", "ENFILE", "EBUSY"]);
 var retryBusy = (fn) => {
-  const method = async (path81, opt, backoff = 1, total = 0) => {
+  const method = async (path82, 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(path81);
+        return await fn(path82);
       } catch (er) {
-        if (isFsError(er) && er.path === path81 && codes2.has(er.code)) {
+        if (isFsError(er) && er.path === path82 && codes2.has(er.code)) {
           backoff = Math.ceil(backoff * rate);
           total = backoff + total;
           if (total < mbo) {
             await setTimeout2(backoff);
-            return method(path81, opt, backoff, total);
+            return method(path82, opt, backoff, total);
           }
           if (retries < max) {
             retries++;
@@ -21635,14 +21616,14 @@ var retryBusy = (fn) => {
   return method;
 };
 var retryBusySync = (fn) => {
-  const method = (path81, opt) => {
+  const method = (path82, opt) => {
     const max = opt.maxRetries || MAXRETRIES;
     let retries = 0;
     while (true) {
       try {
-        return fn(path81);
+        return fn(path82);
       } catch (er) {
-        if (isFsError(er) && er.path === path81 && codes2.has(er.code) && retries < max) {
+        if (isFsError(er) && er.path === path82 && codes2.has(er.code) && retries < max) {
           retries++;
           continue;
         }
@@ -21662,16 +21643,16 @@ init_esm_shims();
 import { tmpdir } from "os";
 import { parse as parse6, resolve as resolve3 } from "path";
 var { stat } = promises2;
-var isDirSync = (path81) => {
+var isDirSync = (path82) => {
   try {
-    return statSync2(path81).isDirectory();
+    return statSync2(path82).isDirectory();
   } catch {
     return false;
   }
 };
-var isDir = (path81) => stat(path81).then((st2) => st2.isDirectory(), () => false);
-var win32DefaultTmp = async (path81) => {
-  const { root } = parse6(path81);
+var isDir = (path82) => stat(path82).then((st2) => st2.isDirectory(), () => false);
+var win32DefaultTmp = async (path82) => {
+  const { root } = parse6(path82);
   const tmp = tmpdir();
   const { root: tmpRoot } = parse6(tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -21683,8 +21664,8 @@ var win32DefaultTmp = async (path81) => {
   }
   return root;
 };
-var win32DefaultTmpSync = (path81) => {
-  const { root } = parse6(path81);
+var win32DefaultTmpSync = (path82) => {
+  const { root } = parse6(path82);
   const tmp = tmpdir();
   const { root: tmpRoot } = parse6(tmp);
   if (root.toLowerCase() === tmpRoot.toLowerCase()) {
@@ -21703,22 +21684,22 @@ var defaultTmpSync = process.platform === "win32" ? win32DefaultTmpSync : posixD
 
 // ../../node_modules/.pnpm/rimraf@6.1.3/node_modules/rimraf/dist/esm/rimraf-move-remove.js
 var { lstat: lstat2, rename, unlink: unlink2, rmdir: rmdir2 } = promises2;
-var uniqueFilename = (path81) => `.${basename(path81)}.${Math.random()}`;
+var uniqueFilename = (path82) => `.${basename(path82)}.${Math.random()}`;
 var unlinkFixEPERM = fixEPERM(unlink2);
 var unlinkFixEPERMSync = fixEPERMSync(unlinkSync);
-var rimrafMoveRemove = async (path81, opt) => {
+var rimrafMoveRemove = async (path82, opt) => {
   opt?.signal?.throwIfAborted();
-  return await ignoreENOENT(lstat2(path81).then((stat5) => rimrafMoveRemoveDir(path81, opt, stat5))) ?? true;
+  return await ignoreENOENT(lstat2(path82).then((stat5) => rimrafMoveRemoveDir(path82, opt, stat5))) ?? true;
 };
-var rimrafMoveRemoveDir = async (path81, opt, ent) => {
+var rimrafMoveRemoveDir = async (path82, opt, ent) => {
   opt?.signal?.throwIfAborted();
   if (!opt.tmp) {
-    return rimrafMoveRemoveDir(path81, { ...opt, tmp: await defaultTmp(path81) }, ent);
+    return rimrafMoveRemoveDir(path82, { ...opt, tmp: await defaultTmp(path82) }, ent);
   }
-  if (path81 === opt.tmp && parse7(path81).root !== path81) {
+  if (path82 === opt.tmp && parse7(path82).root !== path82) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? await readdirOrError(path81) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path82) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -21728,44 +21709,44 @@ var rimrafMoveRemoveDir = async (path81, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path81, ent)) {
+    if (opt.filter && !await opt.filter(path82, ent)) {
       return false;
     }
-    await ignoreENOENT(tmpUnlink(path81, opt.tmp, unlinkFixEPERM));
+    await ignoreENOENT(tmpUnlink(path82, opt.tmp, unlinkFixEPERM));
     return true;
   }
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(resolve4(path81, ent2.name), opt, ent2)))).every((v2) => v2 === true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafMoveRemoveDir(resolve4(path82, ent2.name), opt, ent2)))).every((v2) => v2 === true);
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path81 === parse7(path81).root) {
+  if (opt.preserveRoot === false && path82 === parse7(path82).root) {
     return false;
   }
-  if (opt.filter && !await opt.filter(path81, ent)) {
+  if (opt.filter && !await opt.filter(path82, ent)) {
     return false;
   }
-  await ignoreENOENT(tmpUnlink(path81, opt.tmp, rmdir2));
+  await ignoreENOENT(tmpUnlink(path82, opt.tmp, rmdir2));
   return true;
 };
-var tmpUnlink = async (path81, tmp, rm2) => {
-  const tmpFile = resolve4(tmp, uniqueFilename(path81));
-  await rename(path81, tmpFile);
+var tmpUnlink = async (path82, tmp, rm2) => {
+  const tmpFile = resolve4(tmp, uniqueFilename(path82));
+  await rename(path82, tmpFile);
   return await rm2(tmpFile);
 };
-var rimrafMoveRemoveSync = (path81, opt) => {
+var rimrafMoveRemoveSync = (path82, opt) => {
   opt?.signal?.throwIfAborted();
-  return ignoreENOENTSync(() => rimrafMoveRemoveDirSync(path81, opt, lstatSync(path81))) ?? true;
+  return ignoreENOENTSync(() => rimrafMoveRemoveDirSync(path82, opt, lstatSync(path82))) ?? true;
 };
-var rimrafMoveRemoveDirSync = (path81, opt, ent) => {
+var rimrafMoveRemoveDirSync = (path82, opt, ent) => {
   opt?.signal?.throwIfAborted();
   if (!opt.tmp) {
-    return rimrafMoveRemoveDirSync(path81, { ...opt, tmp: defaultTmpSync(path81) }, ent);
+    return rimrafMoveRemoveDirSync(path82, { ...opt, tmp: defaultTmpSync(path82) }, ent);
   }
   const tmp = opt.tmp;
-  if (path81 === opt.tmp && parse7(path81).root !== path81) {
+  if (path82 === opt.tmp && parse7(path82).root !== path82) {
     throw new Error("cannot delete temp directory used for deletion");
   }
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path81) : null;
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path82) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -21775,32 +21756,32 @@ var rimrafMoveRemoveDirSync = (path81, opt, ent) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path81, ent)) {
+    if (opt.filter && !opt.filter(path82, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => tmpUnlinkSync(path81, tmp, unlinkFixEPERMSync));
+    ignoreENOENTSync(() => tmpUnlinkSync(path82, tmp, unlinkFixEPERMSync));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
-    const p = resolve4(path81, ent2.name);
+    const p = resolve4(path82, ent2.name);
     removedAll = rimrafMoveRemoveDirSync(p, opt, ent2) && removedAll;
   }
   if (!removedAll) {
     return false;
   }
-  if (opt.preserveRoot === false && path81 === parse7(path81).root) {
+  if (opt.preserveRoot === false && path82 === parse7(path82).root) {
     return false;
   }
-  if (opt.filter && !opt.filter(path81, ent)) {
+  if (opt.filter && !opt.filter(path82, ent)) {
     return false;
   }
-  ignoreENOENTSync(() => tmpUnlinkSync(path81, tmp, rmdirSync));
+  ignoreENOENTSync(() => tmpUnlinkSync(path82, tmp, rmdirSync));
   return true;
 };
-var tmpUnlinkSync = (path81, tmp, rmSync2) => {
-  const tmpFile = resolve4(tmp, uniqueFilename(path81));
-  renameSync(path81, tmpFile);
+var tmpUnlinkSync = (path82, tmp, rmSync2) => {
+  const tmpFile = resolve4(tmp, uniqueFilename(path82));
+  renameSync(path82, tmpFile);
   return rmSync2(tmpFile);
 };
 
@@ -21810,26 +21791,26 @@ var rimrafWindowsFile = retryBusy(fixEPERM(unlink3));
 var rimrafWindowsFileSync = retryBusySync(fixEPERMSync(unlinkSync));
 var rimrafWindowsDirRetry = retryBusy(fixEPERM(rmdir3));
 var rimrafWindowsDirRetrySync = retryBusySync(fixEPERMSync(rmdirSync));
-var rimrafWindowsDirMoveRemoveFallback = async (path81, { filter: filter2, ...opt }) => {
+var rimrafWindowsDirMoveRemoveFallback = async (path82, { filter: filter2, ...opt }) => {
   opt?.signal?.throwIfAborted();
   try {
-    await rimrafWindowsDirRetry(path81, opt);
+    await rimrafWindowsDirRetry(path82, opt);
     return true;
   } catch (er) {
     if (errorCode(er) === "ENOTEMPTY") {
-      return rimrafMoveRemove(path81, opt);
+      return rimrafMoveRemove(path82, opt);
     }
     throw er;
   }
 };
-var rimrafWindowsDirMoveRemoveFallbackSync = (path81, { filter: filter2, ...opt }) => {
+var rimrafWindowsDirMoveRemoveFallbackSync = (path82, { filter: filter2, ...opt }) => {
   opt?.signal?.throwIfAborted();
   try {
-    rimrafWindowsDirRetrySync(path81, opt);
+    rimrafWindowsDirRetrySync(path82, opt);
     return true;
   } catch (er) {
     if (errorCode(er) === "ENOTEMPTY") {
-      return rimrafMoveRemoveSync(path81, opt);
+      return rimrafMoveRemoveSync(path82, opt);
     }
     throw er;
   }
@@ -21837,17 +21818,17 @@ var rimrafWindowsDirMoveRemoveFallbackSync = (path81, { filter: filter2, ...opt
 var START = /* @__PURE__ */ Symbol("start");
 var CHILD = /* @__PURE__ */ Symbol("child");
 var FINISH = /* @__PURE__ */ Symbol("finish");
-var rimrafWindows = async (path81, opt) => {
+var rimrafWindows = async (path82, opt) => {
   opt?.signal?.throwIfAborted();
-  return await ignoreENOENT(lstat3(path81).then((stat5) => rimrafWindowsDir(path81, opt, stat5, START))) ?? true;
+  return await ignoreENOENT(lstat3(path82).then((stat5) => rimrafWindowsDir(path82, opt, stat5, START))) ?? true;
 };
-var rimrafWindowsSync = (path81, opt) => {
+var rimrafWindowsSync = (path82, opt) => {
   opt?.signal?.throwIfAborted();
-  return ignoreENOENTSync(() => rimrafWindowsDirSync(path81, opt, lstatSync(path81), START)) ?? true;
+  return ignoreENOENTSync(() => rimrafWindowsDirSync(path82, opt, lstatSync(path82), START)) ?? true;
 };
-var rimrafWindowsDir = async (path81, opt, ent, state = START) => {
+var rimrafWindowsDir = async (path82, opt, ent, state = START) => {
   opt?.signal?.throwIfAborted();
-  const entries = ent.isDirectory() ? await readdirOrError(path81) : null;
+  const entries = ent.isDirectory() ? await readdirOrError(path82) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -21857,32 +21838,32 @@ var rimrafWindowsDir = async (path81, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !await opt.filter(path81, ent)) {
+    if (opt.filter && !await opt.filter(path82, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsFile(path81, opt));
+    await ignoreENOENT(rimrafWindowsFile(path82, opt));
     return true;
   }
   const s = state === START ? CHILD : state;
-  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(resolve5(path81, ent2.name), opt, ent2, s)))).every((v2) => v2 === true);
+  const removedAll = (await Promise.all(entries.map((ent2) => rimrafWindowsDir(resolve5(path82, ent2.name), opt, ent2, s)))).every((v2) => v2 === true);
   if (state === START) {
-    return rimrafWindowsDir(path81, opt, ent, FINISH);
+    return rimrafWindowsDir(path82, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path81 === parse8(path81).root) {
+    if (opt.preserveRoot === false && path82 === parse8(path82).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !await opt.filter(path81, ent)) {
+    if (opt.filter && !await opt.filter(path82, ent)) {
       return false;
     }
-    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path81, opt));
+    await ignoreENOENT(rimrafWindowsDirMoveRemoveFallback(path82, opt));
   }
   return true;
 };
-var rimrafWindowsDirSync = (path81, opt, ent, state = START) => {
-  const entries = ent.isDirectory() ? readdirOrErrorSync(path81) : null;
+var rimrafWindowsDirSync = (path82, opt, ent, state = START) => {
+  const entries = ent.isDirectory() ? readdirOrErrorSync(path82) : null;
   if (!Array.isArray(entries)) {
     if (entries) {
       if (errorCode(entries) === "ENOENT") {
@@ -21892,31 +21873,31 @@ var rimrafWindowsDirSync = (path81, opt, ent, state = START) => {
         throw entries;
       }
     }
-    if (opt.filter && !opt.filter(path81, ent)) {
+    if (opt.filter && !opt.filter(path82, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => rimrafWindowsFileSync(path81, opt));
+    ignoreENOENTSync(() => rimrafWindowsFileSync(path82, opt));
     return true;
   }
   let removedAll = true;
   for (const ent2 of entries) {
     const s = state === START ? CHILD : state;
-    const p = resolve5(path81, ent2.name);
+    const p = resolve5(path82, ent2.name);
     removedAll = rimrafWindowsDirSync(p, opt, ent2, s) && removedAll;
   }
   if (state === START) {
-    return rimrafWindowsDirSync(path81, opt, ent, FINISH);
+    return rimrafWindowsDirSync(path82, opt, ent, FINISH);
   } else if (state === FINISH) {
-    if (opt.preserveRoot === false && path81 === parse8(path81).root) {
+    if (opt.preserveRoot === false && path82 === parse8(path82).root) {
       return false;
     }
     if (!removedAll) {
       return false;
     }
-    if (opt.filter && !opt.filter(path81, ent)) {
+    if (opt.filter && !opt.filter(path82, ent)) {
       return false;
     }
-    ignoreENOENTSync(() => rimrafWindowsDirMoveRemoveFallbackSync(path81, opt));
+    ignoreENOENTSync(() => rimrafWindowsDirMoveRemoveFallbackSync(path82, opt));
   }
   return true;
 };
@@ -21928,16 +21909,16 @@ var rimrafManualSync = process.platform === "win32" ? rimrafWindowsSync : rimraf
 // ../../node_modules/.pnpm/rimraf@6.1.3/node_modules/rimraf/dist/esm/rimraf-native.js
 init_esm_shims();
 var { rm } = promises2;
-var rimrafNative = async (path81, opt) => {
-  await rm(path81, {
+var rimrafNative = async (path82, opt) => {
+  await rm(path82, {
     ...opt,
     force: true,
     recursive: true
   });
   return true;
 };
-var rimrafNativeSync = (path81, opt) => {
-  rmSync(path81, {
+var rimrafNativeSync = (path82, opt) => {
+  rmSync(path82, {
     ...opt,
     force: true,
     recursive: true
@@ -21953,26 +21934,26 @@ var useNative = !hasNative || process.platform === "win32" ? () => false : (opt)
 var useNativeSync = !hasNative || process.platform === "win32" ? () => false : (opt) => !opt?.signal && !opt?.filter;
 
 // ../../node_modules/.pnpm/rimraf@6.1.3/node_modules/rimraf/dist/esm/index.js
-var wrap = (fn) => async (path81, opt) => {
+var wrap = (fn) => async (path82, opt) => {
   const options = optArg(opt);
   if (options.glob) {
-    path81 = await Ze(path81, options.glob);
+    path82 = await Ze(path82, options.glob);
   }
-  if (Array.isArray(path81)) {
-    return !!(await Promise.all(path81.map((p) => fn(path_arg_default(p, options), options)))).reduce((a3, b) => a3 && b, true);
+  if (Array.isArray(path82)) {
+    return !!(await Promise.all(path82.map((p) => fn(path_arg_default(p, options), options)))).reduce((a3, b) => a3 && b, true);
   } else {
-    return !!await fn(path_arg_default(path81, options), options);
+    return !!await fn(path_arg_default(path82, options), options);
   }
 };
-var wrapSync = (fn) => (path81, opt) => {
+var wrapSync = (fn) => (path82, opt) => {
   const options = optArgSync(opt);
   if (options.glob) {
-    path81 = ts(path81, options.glob);
+    path82 = ts(path82, options.glob);
   }
-  if (Array.isArray(path81)) {
-    return !!path81.map((p) => fn(path_arg_default(p, options), options)).reduce((a3, b) => a3 && b, true);
+  if (Array.isArray(path82)) {
+    return !!path82.map((p) => fn(path_arg_default(p, options), options)).reduce((a3, b) => a3 && b, true);
   } else {
-    return !!fn(path_arg_default(path81, options), options);
+    return !!fn(path_arg_default(path82, options), options);
   }
 };
 var nativeSync = wrapSync(rimrafNativeSync);
@@ -21993,8 +21974,8 @@ var moveRemoveSync = wrapSync(rimrafMoveRemoveSync);
 var moveRemove = Object.assign(wrap(rimrafMoveRemove), {
   sync: moveRemoveSync
 });
-var rimrafSync = wrapSync((path81, opt) => useNativeSync(opt) ? rimrafNativeSync(path81, opt) : rimrafManualSync(path81, opt));
-var rimraf_ = wrap((path81, opt) => useNative(opt) ? rimrafNative(path81, opt) : rimrafManual(path81, opt));
+var rimrafSync = wrapSync((path82, opt) => useNativeSync(opt) ? rimrafNativeSync(path82, opt) : rimrafManualSync(path82, opt));
+var rimraf_ = wrap((path82, opt) => useNative(opt) ? rimrafNative(path82, opt) : rimrafManual(path82, opt));
 var rimraf = Object.assign(rimraf_, {
   rimraf: rimraf_,
   sync: rimrafSync,
@@ -22188,7 +22169,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat4 : stat2;
     if (wantBigintFsStats) {
-      this._stat = (path81) => statMethod(path81, { bigint: true });
+      this._stat = (path82) => statMethod(path82, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -22213,8 +22194,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path81, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path81));
+          const { path: path82, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path82));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -22254,20 +22235,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path81, depth) {
+  async _exploreDir(path82, depth) {
     let files;
     try {
-      files = await readdir2(path81, this._rdOptions);
+      files = await readdir2(path82, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path81 };
+    return { files, depth, path: path82 };
   }
-  async _formatEntry(dirent, path81) {
+  async _formatEntry(dirent, path82) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path81, basename4));
+      const fullPath = presolve(pjoin(path82, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -22668,16 +22649,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path81, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path82, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path81);
-    emitRaw(rawEvent, evPath, { watchedPath: path81 });
-    if (evPath && path81 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path81, evPath), KEY_LISTENERS, sp.join(path81, evPath));
+    listener(path82);
+    emitRaw(rawEvent, evPath, { watchedPath: path82 });
+    if (evPath && path82 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path82, evPath), KEY_LISTENERS, sp.join(path82, evPath));
     }
   };
   try {
-    return fs_watch(path81, {
+    return fs_watch(path82, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -22693,12 +22674,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path81, fullPath, options, handlers) => {
+var setFsWatchListener = (path82, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path81, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path82, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -22709,7 +22690,7 @@ var setFsWatchListener = (path81, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path81,
+      path82,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -22724,7 +22705,7 @@ var setFsWatchListener = (path81, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path81, "r");
+          const fd = await open(path82, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -22755,7 +22736,7 @@ var setFsWatchListener = (path81, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path81, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path82, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -22777,7 +22758,7 @@ var setFsWatchFileListener = (path81, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path81, curr));
+          foreach(cont.listeners, (listener2) => listener2(path82, curr));
         }
       })
     };
@@ -22807,13 +22788,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path81, listener) {
+  _watchWithNodeFs(path82, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path81);
-    const basename4 = sp.basename(path81);
+    const directory = sp.dirname(path82);
+    const basename4 = sp.basename(path82);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sp.resolve(path81);
+    const absolutePath = sp.resolve(path82);
     const options = {
       persistent: opts.persistent
     };
@@ -22823,12 +22804,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path81, absolutePath, options, {
+      closer = setFsWatchFileListener(path82, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path81, absolutePath, options, {
+      closer = setFsWatchListener(path82, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -22850,7 +22831,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path81, newStats) => {
+    const listener = async (path82, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -22864,11 +22845,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path81);
+            this.fsw._closeFile(path82);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path81, closer2);
+              this.fsw._addPathCloser(path82, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -22900,7 +22881,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, path81, item) {
+  async _handleSymlink(entry, directory, path82, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -22910,7 +22891,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path81);
+        linkPath = await fsrealpath(path82);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -22920,12 +22901,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, path81, entry.stats);
+          this.fsw._emit(EV.CHANGE, path82, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path81, entry.stats);
+        this.fsw._emit(EV.ADD, path82, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -22955,9 +22936,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path81 = sp.join(directory, item);
+      let path82 = sp.join(directory, item);
       current2.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path81, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path82, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -22966,8 +22947,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path81 = sp.join(dir, sp.relative(dir, path81));
-        this._addToNodeFs(path81, initialAdd, wh, depth + 1);
+        path82 = sp.join(dir, sp.relative(dir, path82));
+        this._addToNodeFs(path82, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve8, reject) => {
@@ -23036,13 +23017,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path81, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path82, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path81) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path82) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path81);
+    const wh = this.fsw._getWatchHelpers(path82);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -23058,8 +23039,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path81);
-        const targetPath = follow ? await fsrealpath(path81) : path81;
+        const absPath = sp.resolve(path82);
+        const targetPath = follow ? await fsrealpath(path82) : path82;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -23069,29 +23050,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path81) : path81;
+        const targetPath = follow ? await fsrealpath(path82) : path82;
         if (this.fsw.closed)
           return;
         const parent = sp.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, path81, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path82, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path81), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path82), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path81, closer);
+        this.fsw._addPathCloser(path82, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path81;
+        return path82;
       }
     }
   }
@@ -23134,24 +23115,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath3(path81) {
-  if (typeof path81 !== "string")
+function normalizePath3(path82) {
+  if (typeof path82 !== "string")
     throw new Error("string expected");
-  path81 = sp2.normalize(path81);
-  path81 = path81.replace(/\\/g, "/");
+  path82 = sp2.normalize(path82);
+  path82 = path82.replace(/\\/g, "/");
   let prepend = false;
-  if (path81.startsWith("//"))
+  if (path82.startsWith("//"))
     prepend = true;
-  path81 = path81.replace(DOUBLE_SLASH_RE, "/");
+  path82 = path82.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path81 = "/" + path81;
-  return path81;
+    path82 = "/" + path82;
+  return path82;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path81 = normalizePath3(testString);
+  const path82 = normalizePath3(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path81, stats)) {
+    if (pattern(path82, stats)) {
       return true;
     }
   }
@@ -23189,19 +23170,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path81) => toUnix(sp2.normalize(toUnix(path81)));
-var normalizeIgnored = (cwd = "") => (path81) => {
-  if (typeof path81 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path81) ? path81 : sp2.join(cwd, path81));
+var normalizePathToUnix = (path82) => toUnix(sp2.normalize(toUnix(path82)));
+var normalizeIgnored = (cwd = "") => (path82) => {
+  if (typeof path82 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path82) ? path82 : sp2.join(cwd, path82));
   } else {
-    return path81;
+    return path82;
   }
 };
-var getAbsolutePath = (path81, cwd) => {
-  if (sp2.isAbsolute(path81)) {
-    return path81;
+var getAbsolutePath = (path82, cwd) => {
+  if (sp2.isAbsolute(path82)) {
+    return path82;
   }
-  return sp2.join(cwd, path81);
+  return sp2.join(cwd, path82);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -23266,10 +23247,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path81, follow, fsw) {
+  constructor(path82, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path81;
-    this.path = path81 = path81.replace(REPLACER_RE, "");
+    const watchPath = path82;
+    this.path = path82 = path82.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -23409,20 +23390,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path81) => {
-        const absPath = getAbsolutePath(path81, cwd);
+      paths = paths.map((path82) => {
+        const absPath = getAbsolutePath(path82, cwd);
         return absPath;
       });
     }
-    paths.forEach((path81) => {
-      this._removeIgnoredPath(path81);
+    paths.forEach((path82) => {
+      this._removeIgnoredPath(path82);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path81) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path81, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path82) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path82, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -23444,17 +23425,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path81) => {
-      if (!sp2.isAbsolute(path81) && !this._closers.has(path81)) {
+    paths.forEach((path82) => {
+      if (!sp2.isAbsolute(path82) && !this._closers.has(path82)) {
         if (cwd)
-          path81 = sp2.join(cwd, path81);
-        path81 = sp2.resolve(path81);
+          path82 = sp2.join(cwd, path82);
+        path82 = sp2.resolve(path82);
       }
-      this._closePath(path81);
-      this._addIgnoredPath(path81);
-      if (this._watched.has(path81)) {
+      this._closePath(path82);
+      this._addIgnoredPath(path82);
+      if (this._watched.has(path82)) {
         this._addIgnoredPath({
-          path: path81,
+          path: path82,
           recursive: true
         });
       }
@@ -23518,38 +23499,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, path81, stats) {
+  async _emit(event, path82, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path81 = sp2.normalize(path81);
+      path82 = sp2.normalize(path82);
     if (opts.cwd)
-      path81 = sp2.relative(opts.cwd, path81);
-    const args = [path81];
+      path82 = sp2.relative(opts.cwd, path82);
+    const args = [path82];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path81))) {
+    if (awf && (pw = this._pendingWrites.get(path82))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path81, [event, ...args]);
+        this._pendingUnlinks.set(path82, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path82) => {
+          this._pendingUnlinks.forEach((entry, path83) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path82);
+            this._pendingUnlinks.delete(path83);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path81)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path82)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path81);
+        this._pendingUnlinks.delete(path82);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -23567,16 +23548,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path81, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path82, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path81, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path82, 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 ? sp2.join(opts.cwd, path81) : path81;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path82) : path82;
       let stats2;
       try {
         stats2 = await stat4(fullPath);
@@ -23607,23 +23588,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, path81, timeout) {
+  _throttle(actionType, path82, 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(path81);
+    const actionPath = action.get(path82);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path81);
+      const item = action.get(path82);
       const count = item ? item.count : 0;
-      action.delete(path81);
+      action.delete(path82);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -23631,7 +23612,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path81, thr);
+    action.set(path82, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -23645,44 +23626,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path81, threshold, event, awfEmit) {
+  _awaitWriteFinish(path82, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path81;
-    if (this.options.cwd && !sp2.isAbsolute(path81)) {
-      fullPath = sp2.join(this.options.cwd, path81);
+    let fullPath = path82;
+    if (this.options.cwd && !sp2.isAbsolute(path82)) {
+      fullPath = sp2.join(this.options.cwd, path82);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path81)) {
+        if (err || !writes.has(path82)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path81).lastChange = now2;
+          writes.get(path82).lastChange = now2;
         }
-        const pw = writes.get(path81);
+        const pw = writes.get(path82);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path81);
+          writes.delete(path82);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path81)) {
-      writes.set(path81, {
+    if (!writes.has(path82)) {
+      writes.set(path82, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path81);
+          writes.delete(path82);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -23693,8 +23674,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path81, stats) {
-    if (this.options.atomic && DOT_RE.test(path81))
+  _isIgnored(path82, stats) {
+    if (this.options.atomic && DOT_RE.test(path82))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -23704,17 +23685,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path81, stats);
+    return this._userIgnored(path82, stats);
   }
-  _isntIgnored(path81, stat5) {
-    return !this._isIgnored(path81, stat5);
+  _isntIgnored(path82, stat5) {
+    return !this._isIgnored(path82, stat5);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path81) {
-    return new WatchHelper(path81, this.options.followSymlinks, this);
+  _getWatchHelpers(path82) {
+    return new WatchHelper(path82, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -23746,63 +23727,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path81 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path81);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path81) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path81, 100))
+    const path82 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path82);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path82) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path82, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path81);
+    const wp = this._getWatchedDir(path82);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path81, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path82, 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 = path81;
+    let relPath = path82;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path81);
+      relPath = sp2.relative(this.options.cwd, path82);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path81);
+    this._watched.delete(path82);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path81))
-      this._emit(eventName, path81);
-    this._closePath(path81);
+    if (wasTracked && !this._isIgnored(path82))
+      this._emit(eventName, path82);
+    this._closePath(path82);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path81) {
-    this._closeFile(path81);
-    const dir = sp2.dirname(path81);
-    this._getWatchedDir(dir).remove(sp2.basename(path81));
+  _closePath(path82) {
+    this._closeFile(path82);
+    const dir = sp2.dirname(path82);
+    this._getWatchedDir(dir).remove(sp2.basename(path82));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path81) {
-    const closers = this._closers.get(path81);
+  _closeFile(path82) {
+    const closers = this._closers.get(path82);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path81);
+    this._closers.delete(path82);
   }
-  _addPathCloser(path81, closer) {
+  _addPathCloser(path82, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path81);
+    let list = this._closers.get(path82);
     if (!list) {
       list = [];
-      this._closers.set(path81, list);
+      this._closers.set(path82, list);
     }
     list.push(closer);
   }
@@ -24270,7 +24251,7 @@ function isMetadataYarnClassic(metadataPath) {
 }
 
 // src/runtime/config/createConfigService.ts
-import path71 from "pathe";
+import path72 from "pathe";
 
 // src/platform.ts
 init_esm_shims();
@@ -25450,7 +25431,7 @@ function mergeInlineConfig(config, injectBuiltinAliases, ...configs) {
 // src/runtime/config/internal/merge/miniprogram.ts
 init_esm_shims();
 import { defu as defu5 } from "@weapp-core/shared";
-import path70 from "pathe";
+import path71 from "pathe";
 
 // src/runtime/config/internal/merge/plugins.ts
 init_esm_shims();
@@ -25751,10 +25732,12 @@ import path43 from "pathe";
 var AUTO_ROUTES_ID = "weapp-vite/auto-routes";
 var VIRTUAL_MODULE_ID = "virtual:weapp-vite-auto-routes";
 var RESOLVED_VIRTUAL_ID = "\0weapp-vite:auto-routes";
+var ROUTE_WATCHER_KEY = "__auto-routes-vue-watcher__";
 function createAutoRoutesPlugin(ctx) {
   const service = ctx.autoRoutesService;
   let resolvedConfig;
   const autoRoutesAliasTargets = /* @__PURE__ */ new Set();
+  let routeWatcherStarted = false;
   const normalizeTargetId = (id) => {
     return path43.normalize(normalizeFsResolvedId(id));
   };
@@ -25810,6 +25793,62 @@ function createAutoRoutesPlugin(ctx) {
     }
     return relative3 === "pages" || relative3.startsWith("pages/") || relative3.includes("/pages/");
   }
+  function startRouteFileWatcher() {
+    if (routeWatcherStarted) {
+      return;
+    }
+    const configService = ctx.configService;
+    if (!configService?.isDev) {
+      return;
+    }
+    if (!service.isEnabled()) {
+      return;
+    }
+    const srcRoot = configService.absoluteSrcRoot;
+    const allowedExtensions = new Set(vueExtensions.map((ext) => `.${ext}`));
+    const watchDirs = [];
+    for (const dir of service.getWatchDirectories()) {
+      watchDirs.push(dir);
+    }
+    const defaultPagesDir = path43.join(srcRoot, "pages");
+    if (!watchDirs.some((d) => normalizePath(d) === normalizePath(defaultPagesDir))) {
+      watchDirs.push(defaultPagesDir);
+    }
+    if (!watchDirs.length) {
+      return;
+    }
+    const isRouteVueFile = (filePath) => {
+      const ext = path43.extname(filePath);
+      return allowedExtensions.has(ext) && isPagesRelatedPath(filePath);
+    };
+    const watcher = chokidar_default.watch(watchDirs, {
+      ignoreInitial: true,
+      persistent: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 80,
+        pollInterval: 20
+      }
+    });
+    watcher.on("add", (filePath) => {
+      if (!isRouteVueFile(filePath)) {
+        return;
+      }
+      default2.info(`[auto-routes:watch] \u65B0\u589E\u8DEF\u7531\u6587\u4EF6 ${configService.relativeCwd(filePath)}`);
+      void service.handleFileChange(filePath, "create");
+    });
+    watcher.on("unlink", (filePath) => {
+      if (!isRouteVueFile(filePath)) {
+        return;
+      }
+      default2.info(`[auto-routes:watch] \u5220\u9664\u8DEF\u7531\u6587\u4EF6 ${configService.relativeCwd(filePath)}`);
+      void service.handleFileChange(filePath, "delete");
+    });
+    const { sidecarWatcherMap } = ctx.runtimeState.watcher;
+    sidecarWatcherMap.set(ROUTE_WATCHER_KEY, {
+      close: () => void watcher.close()
+    });
+    routeWatcherStarted = true;
+  }
   return {
     name: "weapp-vite:auto-routes",
     enforce: "pre",
@@ -25821,6 +25860,7 @@ function createAutoRoutesPlugin(ctx) {
       await service.ensureFresh();
       refreshAutoRoutesAliasTargets();
       addWatchTargets(this);
+      startRouteFileWatcher();
     },
     resolveId(id) {
       if (id === AUTO_ROUTES_ID || id === VIRTUAL_MODULE_ID) {
@@ -27080,8 +27120,8 @@ function transformWxsCode(code, options) {
     }
     importees.push({ source: value });
   };
-  const tryCollectArgument = (path81) => {
-    const node = path81.node;
+  const tryCollectArgument = (path82) => {
+    const node = path82.node;
     if (t.isStringLiteral(node)) {
       maybePushImportee(node.value);
       return;
@@ -27092,7 +27132,7 @@ function transformWxsCode(code, options) {
       return;
     }
     try {
-      const evaluated = path81.evaluate();
+      const evaluated = path82.evaluate();
       if (evaluated.confident) {
         maybePushImportee(evaluated.value);
       }
@@ -27745,6 +27785,7 @@ init_esm_shims();
 
 // src/plugins/core/lifecycle/emit.ts
 init_esm_shims();
+import path53 from "pathe";
 
 // src/utils/weapi.ts
 init_esm_shims();
@@ -27786,6 +27827,11 @@ function createWeapiAccessExpression(globalName) {
 
 // src/plugins/core/lifecycle/emit.ts
 var platformApiIdentifiers = /* @__PURE__ */ new Set(["wx", "my", "tt", "swan", "jd", "xhs"]);
+var WINDOWS_SEPARATOR_RE = /\\/g;
+var NPM_PROTOCOL_RE = /^npm:/;
+var PLUGIN_PROTOCOL_RE = /^plugin:\/\//;
+var ABSOLUTE_NPM_PREFIX_RE = /^\/(?:miniprogram_npm|node_modules)\//;
+var PRETTY_NODE_MODULES_RE = /node_modules\/(?:\.pnpm\/[^/]+\/node_modules\/)?(.+)/;
 function resolveInjectWeapiGlobalName(state) {
   const injectWeapi = state.ctx.configService.weappViteConfig?.injectWeapi;
   if (!injectWeapi) {
@@ -27802,8 +27848,8 @@ function replacePlatformApiAccess(code, globalName) {
   try {
     const ast = parseJsLike(code);
     let mutated = false;
-    const rewritePath = (path81) => {
-      const object = path81.node?.object;
+    const rewritePath = (path82) => {
+      const object = path82.node?.object;
       if (!object || object.type !== "Identifier") {
         return;
       }
@@ -27811,10 +27857,10 @@ function replacePlatformApiAccess(code, globalName) {
       if (!platformApiIdentifiers.has(identifierName)) {
         return;
       }
-      if (path81.scope?.hasBinding?.(identifierName)) {
+      if (path82.scope?.hasBinding?.(identifierName)) {
         return;
       }
-      path81.node.object = {
+      path82.node.object = {
         type: "Identifier",
         name: injectedApiIdentifier2
       };
@@ -27839,13 +27885,13 @@ function hasDependencyPrefix3(dependencies, importee) {
   if (!dependencies) {
     return false;
   }
-  const normalizedImportee = importee.replace(/\\/g, "/").replace(/^npm:/, "");
+  const normalizedImportee = importee.replace(WINDOWS_SEPARATOR_RE, "/").replace(NPM_PROTOCOL_RE, "");
   const importeeTokens = normalizedImportee.split("/").filter(Boolean);
   if (importeeTokens.length === 0) {
     return false;
   }
   return Object.keys(dependencies).some((dep) => {
-    const depTokens = dep.replace(/\\/g, "/").split("/").filter(Boolean);
+    const depTokens = dep.replace(WINDOWS_SEPARATOR_RE, "/").split("/").filter(Boolean);
     if (depTokens.length === 0 || depTokens.length > importeeTokens.length) {
       return false;
     }
@@ -27857,12 +27903,23 @@ function hasDependencyPrefix3(dependencies, importee) {
     return true;
   });
 }
+function resolveDependencyId(importee) {
+  const normalizedImportee = importee.replace(WINDOWS_SEPARATOR_RE, "/").replace(NPM_PROTOCOL_RE, "").replace(ABSOLUTE_NPM_PREFIX_RE, "");
+  const importeeTokens = normalizedImportee.split("/").filter(Boolean);
+  if (importeeTokens.length === 0) {
+    return "";
+  }
+  if (normalizedImportee.startsWith("@") && importeeTokens.length > 1) {
+    return `${importeeTokens[0]}/${importeeTokens[1]}`;
+  }
+  return importeeTokens[0];
+}
 function normalizeNpmImportForAlipay(importee, dependencies, mode) {
   const trimmed = importee.trim();
-  if (!trimmed || /^plugin:\/\//.test(trimmed)) {
+  if (!trimmed || PLUGIN_PROTOCOL_RE.test(trimmed)) {
     return importee;
   }
-  const normalized = trimmed.replace(/^npm:/, "");
+  const normalized = trimmed.replace(NPM_PROTOCOL_RE, "");
   if (normalized.startsWith("/miniprogram_npm/") || normalized.startsWith("/node_modules/")) {
     return normalizeAlipayNpmImportPath(normalized, mode);
   }
@@ -27876,15 +27933,15 @@ function rewriteChunkNpmImportsForAlipay(code, dependencies, mode) {
     const ast = parseJsLike(code);
     let mutated = false;
     traverse(ast, {
-      CallExpression(path81) {
-        const callee = path81.node?.callee;
+      CallExpression(path82) {
+        const callee = path82.node?.callee;
         if (!callee || callee.type !== "Identifier" || callee.name !== "require") {
           return;
         }
-        if (path81.scope?.hasBinding?.("require")) {
+        if (path82.scope?.hasBinding?.("require")) {
           return;
         }
-        const args = path81.node.arguments;
+        const args = path82.node.arguments;
         if (!Array.isArray(args) || args.length === 0) {
           return;
         }
@@ -27948,6 +28005,131 @@ function rewriteBundlePlatformApi(bundle, globalName) {
     chunk.code = nextCode;
   }
 }
+function matchesSubPackageDependency(dependencies, importee, fallbackDependencies) {
+  const normalized = importee.replace(NPM_PROTOCOL_RE, "").replace(ABSOLUTE_NPM_PREFIX_RE, "");
+  if (Array.isArray(dependencies) && dependencies.length > 0) {
+    const dependencyId = resolveDependencyId(normalized);
+    return dependencies.some((pattern) => {
+      if (typeof pattern === "string") {
+        return dependencyId === pattern || normalized === pattern || normalized.startsWith(`${pattern}/`);
+      }
+      pattern.lastIndex = 0;
+      if (pattern.test(dependencyId)) {
+        return true;
+      }
+      pattern.lastIndex = 0;
+      return pattern.test(normalized);
+    });
+  }
+  return hasDependencyPrefix3(fallbackDependencies, normalized);
+}
+function normalizeWeappLocalNpmImport(importee) {
+  const normalized = importee.replace(NPM_PROTOCOL_RE, "").replace(ABSOLUTE_NPM_PREFIX_RE, "");
+  const segments = normalized.split("/").filter(Boolean);
+  if (segments.length === 1 || segments.length === 2 && normalized.startsWith("@")) {
+    return `${normalized}/index`;
+  }
+  return normalized;
+}
+function getRequireImportLiteral(node) {
+  if (!node) {
+    return null;
+  }
+  if (node.type === "StringLiteral" || node.type === "Literal") {
+    return typeof node.value === "string" ? node.value : null;
+  }
+  if (node.type === "TemplateLiteral" && node.expressions?.length === 0 && node.quasis?.length === 1) {
+    return node.quasis[0]?.value?.cooked ?? null;
+  }
+  return null;
+}
+function setRequireImportLiteral(node, nextValue) {
+  if (!node) {
+    return;
+  }
+  if (node.type === "StringLiteral" || node.type === "Literal") {
+    node.value = nextValue;
+    return;
+  }
+  if (node.type === "TemplateLiteral" && node.expressions?.length === 0 && node.quasis?.length === 1) {
+    node.quasis[0].value.raw = nextValue;
+    node.quasis[0].value.cooked = nextValue;
+  }
+}
+function toRelativeRuntimeNpmImport(fileName, root, importee) {
+  const normalized = normalizeWeappLocalNpmImport(importee);
+  const relative3 = toPosixPath(path53.relative(path53.dirname(fileName), `${root}/miniprogram_npm/${normalized}`));
+  return relative3.startsWith(".") ? relative3 : `./${relative3}`;
+}
+function rewriteChunkNpmImportsToLocalSubPackage(chunk, meta, dependencies) {
+  try {
+    const ast = parseJsLike(chunk.code);
+    let mutated = false;
+    traverse(ast, {
+      CallExpression(path82) {
+        const callee = path82.node?.callee;
+        if (!callee || callee.type !== "Identifier" || callee.name !== "require") {
+          return;
+        }
+        if (path82.scope?.hasBinding?.("require")) {
+          return;
+        }
+        const args = path82.node.arguments;
+        if (!Array.isArray(args) || args.length === 0) {
+          return;
+        }
+        const firstArg = args[0];
+        const currentValue = getRequireImportLiteral(firstArg);
+        if (typeof currentValue !== "string" || !matchesSubPackageDependency(meta.subPackage.dependencies, currentValue, dependencies)) {
+          return;
+        }
+        const nextValue = toRelativeRuntimeNpmImport(chunk.fileName, meta.subPackage.root, currentValue);
+        if (nextValue === currentValue) {
+          return;
+        }
+        setRequireImportLiteral(firstArg, nextValue);
+        mutated = true;
+      }
+    });
+    if (mutated) {
+      chunk.code = generate(ast).code;
+    }
+  } catch {
+  }
+}
+function rewriteJsonNpmImportsToLocalSubPackage(bundle, meta, dependencies) {
+  for (const output of Object.values(bundle)) {
+    if (output?.type !== "asset" || typeof output.fileName !== "string" || !output.fileName.endsWith(".json")) {
+      continue;
+    }
+    if (output.fileName === `${meta.subPackage.root}.json` || !output.fileName.startsWith(`${meta.subPackage.root}/`)) {
+      continue;
+    }
+    const source = typeof output.source === "string" ? output.source : output.source?.toString();
+    if (!source) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(source);
+      if (!parsed || typeof parsed !== "object" || !parsed.usingComponents || typeof parsed.usingComponents !== "object" || Array.isArray(parsed.usingComponents)) {
+        continue;
+      }
+      let mutated = false;
+      for (const [componentName, importee] of Object.entries(parsed.usingComponents)) {
+        if (typeof importee !== "string" || !matchesSubPackageDependency(meta.subPackage.dependencies, importee, dependencies)) {
+          continue;
+        }
+        parsed.usingComponents[componentName] = toRelativeRuntimeNpmImport(output.fileName, meta.subPackage.root, importee);
+        mutated = true;
+      }
+      if (mutated) {
+        output.source = `${JSON.stringify(parsed, null, 2)}
+`;
+      }
+    } catch {
+    }
+  }
+}
 function createRenderStartHook(state) {
   const { ctx, subPackageMeta, buildTarget } = state;
   return function renderStart() {
@@ -27986,7 +28168,7 @@ function createGenerateBundleHook(state, isPluginBuild) {
       var matchSubPackage = matchSubPackage2;
       const sharedStrategy = configService.weappViteConfig?.chunks?.sharedStrategy ?? DEFAULT_SHARED_CHUNK_STRATEGY;
       const shouldLogChunks = configService.weappViteConfig?.chunks?.logOptimization ?? true;
-      const subPackageRoots = Array.from(scanService.subPackageMap.keys()).filter(Boolean);
+      const subPackageRoots = [...scanService.subPackageMap.keys()].filter(Boolean);
       const duplicateWarningBytes = Number(configService.weappViteConfig?.chunks?.duplicateWarningBytes ?? 0);
       const shouldWarnOnDuplicate = Number.isFinite(duplicateWarningBytes) && duplicateWarningBytes > 0;
       let redundantBytesTotal = 0;
@@ -27999,7 +28181,7 @@ function createGenerateBundleHook(state, isPluginBuild) {
       const resolveSharedChunkLabel = (sharedFileName, finalFileName) => {
         const prettifyModuleLabel = (label) => {
           const normalized = toPosixPath(label);
-          const match = normalized.match(/node_modules\/(?:\.pnpm\/[^/]+\/node_modules\/)?(.+)/);
+          const match = normalized.match(PRETTY_NODE_MODULES_RE);
           return match?.[1] || label;
         };
         const candidates = [];
@@ -28024,11 +28206,9 @@ function createGenerateBundleHook(state, isPluginBuild) {
         if (!chunk) {
           return finalFileName;
         }
-        const moduleLabels = Array.from(
-          new Set(
-            Object.keys(chunk.modules ?? {}).filter((id) => id && !id.startsWith("\0")).map((id) => configService.relativeAbsoluteSrcRoot(id)).filter(Boolean)
-          )
-        );
+        const moduleLabels = [...new Set(
+          Object.keys(chunk.modules ?? {}).filter((id) => id && !id.startsWith("\0")).map((id) => configService.relativeAbsoluteSrcRoot(id)).filter(Boolean)
+        )];
         if (!moduleLabels.length) {
           return chunk.fileName || finalFileName;
         }
@@ -28072,7 +28252,7 @@ function createGenerateBundleHook(state, isPluginBuild) {
             subPackageSet.add(match);
           }
         }
-        const subPackageList = Array.from(subPackageSet).join("\u3001") || "\u76F8\u5173\u5206\u5305";
+        const subPackageList = [...subPackageSet].join("\u3001") || "\u76F8\u5173\u5206\u5305";
         const ignoredHint = ignoredMainImporters?.length ? `\uFF0C\u5FFD\u7565\u4E3B\u5305\u5F15\u7528\uFF1A${ignoredMainImporters.join("\u3001")}` : "";
         default2.info(`[\u5206\u5305] \u5206\u5305 ${subPackageList} \u5171\u4EAB\u6A21\u5757\u5DF2\u590D\u5236\u5230\u5404\u81EA weapp-shared/common.js\uFF08${totalReferences} \u5904\u5F15\u7528${ignoredHint}\uFF09`);
         if (retainedInMain) {
@@ -28096,7 +28276,7 @@ function createGenerateBundleHook(state, isPluginBuild) {
           }
           const segments = [];
           if (involvedSubs.size) {
-            segments.push(`\u5206\u5305 ${Array.from(involvedSubs).join("\u3001")}`);
+            segments.push(`\u5206\u5305 ${[...involvedSubs].join("\u3001")}`);
           }
           if (hasMainReference) {
             segments.push("\u4E3B\u5305");
@@ -28121,7 +28301,7 @@ function createGenerateBundleHook(state, isPluginBuild) {
               subPackageSet.add(match);
             }
           }
-          const subPackageList = Array.from(subPackageSet).join("\u3001") || "\u76F8\u5173\u5206\u5305";
+          const subPackageList = [...subPackageSet].join("\u3001") || "\u76F8\u5173\u5206\u5305";
           default2.info(`[\u5206\u5305] \u5206\u5305 ${subPackageList} \u5DF2\u672C\u5730\u5316 ${runtimeFileName} \u4F9D\u8D56\uFF0C\u907F\u514D\u8DE8\u5305 runtime \u5F15\u7528\u3002`);
         } : void 0
       });
@@ -28135,6 +28315,22 @@ function createGenerateBundleHook(state, isPluginBuild) {
     });
     if (configService.platform === "alipay") {
       rewriteBundleNpmImportsForAlipay(rolldownBundle, configService.packageJson.dependencies, configService.weappViteConfig?.npm?.alipayNpmMode);
+    } else {
+      const subPackageMap = scanService.subPackageMap ?? /* @__PURE__ */ new Map();
+      const localSubPackageMetas = [...subPackageMap.values()].filter((meta) => Array.isArray(meta?.subPackage?.dependencies) && meta.subPackage.dependencies.length > 0);
+      for (const meta of localSubPackageMetas) {
+        for (const output of Object.values(rolldownBundle)) {
+          if (output?.type !== "chunk") {
+            continue;
+          }
+          const chunk = output;
+          if (chunk.fileName === meta.subPackage.root || !chunk.fileName.startsWith(`${meta.subPackage.root}/`)) {
+            continue;
+          }
+          rewriteChunkNpmImportsToLocalSubPackage(chunk, meta, configService.packageJson.dependencies);
+        }
+        rewriteJsonNpmImportsToLocalSubPackage(rolldownBundle, meta, configService.packageJson.dependencies);
+      }
     }
     const injectWeapiGlobalName = resolveInjectWeapiGlobalName(state);
     if (injectWeapiGlobalName) {
@@ -28172,7 +28368,7 @@ function createBuildEndHook(state) {
 // src/plugins/core/lifecycle/load.ts
 init_esm_shims();
 import { removeExtensionDeep as removeExtensionDeep11 } from "@weapp-core/shared";
-import path53 from "pathe";
+import path54 from "pathe";
 
 // src/plugins/utils/parse.ts
 init_esm_shims();
@@ -28209,7 +28405,7 @@ function createOptionsHook(state) {
     let scannedInput;
     if (subPackageMeta) {
       scannedInput = subPackageMeta.entries.reduce((acc, entry) => {
-        acc[entry] = path53.resolve(configService.absoluteSrcRoot, entry);
+        acc[entry] = path54.resolve(configService.absoluteSrcRoot, entry);
         return acc;
       }, {});
     } else if (configService.weappLibConfig?.enabled) {
@@ -28352,8 +28548,8 @@ function createLoadHook(state) {
     try {
       const ast = parseJsLike(code);
       let mutated = false;
-      const rewritePath = (path81) => {
-        const object = path81.node?.object;
+      const rewritePath = (path82) => {
+        const object = path82.node?.object;
         if (!object || object.type !== "Identifier") {
           return;
         }
@@ -28361,10 +28557,10 @@ function createLoadHook(state) {
         if (!platformApiIdentifiers3.has(identifierName)) {
           return;
         }
-        if (path81.scope?.hasBinding?.(identifierName)) {
+        if (path82.scope?.hasBinding?.(identifierName)) {
           return;
         }
-        path81.node.object = {
+        path82.node.object = {
           type: "Identifier",
           name: injectedApiIdentifier2
         };
@@ -28509,8 +28705,8 @@ function replacePlatformApiAccess2(code, globalName) {
   try {
     const ast = parseJsLike(code);
     let mutated = false;
-    const rewritePath = (path81) => {
-      const object = path81.node?.object;
+    const rewritePath = (path82) => {
+      const object = path82.node?.object;
       if (!object || object.type !== "Identifier") {
         return;
       }
@@ -28518,10 +28714,10 @@ function replacePlatformApiAccess2(code, globalName) {
       if (!platformApiIdentifiers2.has(identifierName)) {
         return;
       }
-      if (path81.scope?.hasBinding?.(identifierName)) {
+      if (path82.scope?.hasBinding?.(identifierName)) {
         return;
       }
-      path81.node.object = {
+      path82.node.object = {
         type: "Identifier",
         name: injectedApiIdentifier
       };
@@ -28565,14 +28761,14 @@ function createTransformHook(state) {
 
 // src/plugins/core/lifecycle/watch.ts
 init_esm_shims();
-import path58 from "pathe";
+import path59 from "pathe";
 
 // src/plugins/css/shared/preprocessor.ts
 init_esm_shims();
 import { createHash as createHash2 } from "crypto";
 import { createRequire as createRequire7 } from "module";
 import fs25 from "fs-extra";
-import path54 from "pathe";
+import path55 from "pathe";
 import { preprocessCSS } from "vite";
 
 // src/postcss/index.ts
@@ -28733,12 +28929,12 @@ async function processCssWithCache(code, configService) {
 }
 function dedupeAndNormalizeDependencies(base, dependencies) {
   const seen = /* @__PURE__ */ new Set();
-  const baseDir = path54.dirname(base);
+  const baseDir = path55.dirname(base);
   for (const dep of dependencies) {
     if (!dep) {
       continue;
     }
-    const normalized = path54.isAbsolute(dep) ? dep : path54.resolve(baseDir, dep);
+    const normalized = path55.isAbsolute(dep) ? dep : path55.resolve(baseDir, dep);
     seen.add(normalized);
   }
   return Array.from(seen);
@@ -28836,7 +29032,7 @@ init_esm_shims();
 // src/plugins/utils/invalidateEntry/cssGraph.ts
 init_esm_shims();
 import fs26 from "fs";
-import path55 from "pathe";
+import path56 from "pathe";
 
 // src/plugins/utils/invalidateEntry/shared.ts
 init_esm_shims();
@@ -28941,7 +29137,7 @@ async function extractCssImportDependencies(ctx, importer) {
   }
   cssImportRE.lastIndex = 0;
   const dependencies = /* @__PURE__ */ new Set();
-  const dir = path55.dirname(importer);
+  const dir = path56.dirname(importer);
   while (true) {
     const match = cssImportRE.exec(cssContent);
     if (!match) {
@@ -28953,9 +29149,9 @@ async function extractCssImportDependencies(ctx, importer) {
     }
     if (importProtocols.test(rawSpecifier)) {
       if (rawSpecifier.startsWith("/")) {
-        const absolute = path55.resolve(ctx.configService.absoluteSrcRoot, rawSpecifier.slice(1));
+        const absolute = path56.resolve(ctx.configService.absoluteSrcRoot, rawSpecifier.slice(1));
         dependencies.add(absolute);
-        const ext2 = path55.extname(absolute);
+        const ext2 = path56.extname(absolute);
         if (ext2) {
           dependencies.add(absolute.slice(0, -ext2.length));
         }
@@ -28964,7 +29160,7 @@ async function extractCssImportDependencies(ctx, importer) {
     }
     let specifier = rawSpecifier;
     if (specifier.startsWith("@/")) {
-      specifier = path55.join(ctx.configService.absoluteSrcRoot, specifier.slice(2));
+      specifier = path56.join(ctx.configService.absoluteSrcRoot, specifier.slice(2));
     } else if (specifier === "@") {
       specifier = ctx.configService.absoluteSrcRoot;
     }
@@ -28972,9 +29168,9 @@ async function extractCssImportDependencies(ctx, importer) {
       specifier = specifier.slice(1);
     }
     const cleaned = specifier.replace(/[?#].*$/, "");
-    const resolved = path55.resolve(dir, cleaned);
+    const resolved = path56.resolve(dir, cleaned);
     dependencies.add(resolved);
-    const ext = path55.extname(resolved);
+    const ext = path56.extname(resolved);
     if (!ext) {
       dependencies.add(resolved);
     } else {
@@ -28993,7 +29189,7 @@ function collectCssImporters(ctx, dependency) {
       matches2.add(importer);
     }
   }
-  const ext = path55.extname(normalizedDependency);
+  const ext = path56.extname(normalizedDependency);
   if (ext) {
     const base = normalizedDependency.slice(0, -ext.length);
     const baseMatches = graph.dependencyToImporters.get(base);
@@ -29027,7 +29223,7 @@ async function collectAffectedScriptsAndImporters(ctx, startCssFile) {
       continue;
     }
     visitedCss.add(current2);
-    const ext = path55.extname(current2);
+    const ext = path56.extname(current2);
     if (ext) {
       const base = current2.slice(0, -ext.length);
       const script = await resolveScriptForCss(scriptCache, base);
@@ -29054,10 +29250,10 @@ function cleanupCssImporterGraph(ctx, importer) {
 
 // src/plugins/utils/invalidateEntry/sidecar.ts
 init_esm_shims();
-import path56 from "pathe";
+import path57 from "pathe";
 async function invalidateEntryForSidecar(ctx, filePath, event = "update") {
   const configSuffix = configSuffixes.find((suffix) => filePath.endsWith(suffix));
-  const ext = path56.extname(filePath);
+  const ext = path57.extname(filePath);
   const normalizedPath = normalizePath(filePath);
   let scriptBasePath;
   if (configSuffix) {
@@ -29122,13 +29318,13 @@ async function invalidateEntryForSidecar(ctx, filePath, event = "update") {
 init_esm_shims();
 import fs27 from "fs";
 import process7 from "process";
-import path57 from "pathe";
+import path58 from "pathe";
 function ensureSidecarWatcher(ctx, rootDir) {
   if (!ctx.configService.isDev || !rootDir || process7.env.VITEST === "true" || process7.env.NODE_ENV === "test" || process7.env.WEAPP_VITE_DISABLE_SIDECAR_WATCH === "1") {
     return;
   }
   const { sidecarWatcherMap } = ctx.runtimeState.watcher;
-  const absRoot = path57.normalize(rootDir);
+  const absRoot = path58.normalize(rootDir);
   if (!fs27.existsSync(absRoot)) {
     return;
   }
@@ -29140,7 +29336,7 @@ function ensureSidecarWatcher(ctx, rootDir) {
     if (!isSidecarFile(filePath)) {
       return;
     }
-    const ext = path57.extname(filePath);
+    const ext = path58.extname(filePath);
     const isCssFile = Boolean(ext && watchedCssExts.has(ext));
     if (isCssFile && (event === "create" || event === "update")) {
       void extractCssImportDependencies(ctx, filePath);
@@ -29161,9 +29357,9 @@ function ensureSidecarWatcher(ctx, rootDir) {
     }
   };
   const patterns = [
-    ...configExtensions.map((ext) => path57.join(absRoot, `**/*.${ext}`)),
-    ...supportedCssLangs.map((ext) => path57.join(absRoot, `**/*.${ext}`)),
-    ...templateExtensions.map((ext) => path57.join(absRoot, `**/*.${ext}`))
+    ...configExtensions.map((ext) => path58.join(absRoot, `**/*.${ext}`)),
+    ...supportedCssLangs.map((ext) => path58.join(absRoot, `**/*.${ext}`)),
+    ...templateExtensions.map((ext) => path58.join(absRoot, `**/*.${ext}`))
   ];
   const ignoredMatcher = createSidecarIgnoredMatcher(ctx, absRoot);
   const watcher = chokidar_default.watch(patterns, {
@@ -29179,15 +29375,15 @@ function ensureSidecarWatcher(ctx, rootDir) {
     if (!input) {
       return;
     }
-    const normalizedPath = path57.normalize(input);
+    const normalizedPath = path58.normalize(input);
     if (!options?.silent) {
       default2.info(`[watch:${event}] ${ctx.configService.relativeCwd(normalizedPath)}`);
     }
     handleSidecarChange(event, normalizedPath, isReady);
   };
-  watcher.on("add", (path81) => forwardChange("create", path81));
-  watcher.on("change", (path81) => forwardChange("update", path81));
-  watcher.on("unlink", (path81) => forwardChange("delete", path81));
+  watcher.on("add", (path82) => forwardChange("create", path82));
+  watcher.on("change", (path82) => forwardChange("update", path82));
+  watcher.on("unlink", (path82) => forwardChange("delete", path82));
   watcher.on("raw", (eventName, rawPath, details) => {
     if (eventName !== "rename") {
       return;
@@ -29197,7 +29393,7 @@ function ensureSidecarWatcher(ctx, rootDir) {
       return;
     }
     const baseDir = typeof details === "object" && details && "watchedPath" in details ? details.watchedPath ?? absRoot : absRoot;
-    const resolved = path57.isAbsolute(candidate) ? candidate : path57.resolve(baseDir, candidate);
+    const resolved = path58.isAbsolute(candidate) ? candidate : path58.resolve(baseDir, candidate);
     if (ignoredMatcher(resolved)) {
       return;
     }
@@ -29225,22 +29421,22 @@ function ensureSidecarWatcher(ctx, rootDir) {
 function createSidecarIgnoredMatcher(ctx, rootDir) {
   const configService = ctx.configService;
   const ignoredRoots = /* @__PURE__ */ new Set();
-  const normalizedRoot = path57.normalize(rootDir);
+  const normalizedRoot = path58.normalize(rootDir);
   for (const dirName of defaultIgnoredDirNames) {
-    ignoredRoots.add(path57.join(normalizedRoot, dirName));
+    ignoredRoots.add(path58.join(normalizedRoot, dirName));
   }
   if (configService?.mpDistRoot) {
-    ignoredRoots.add(path57.resolve(configService.cwd, configService.mpDistRoot));
+    ignoredRoots.add(path58.resolve(configService.cwd, configService.mpDistRoot));
   } else {
-    ignoredRoots.add(path57.join(normalizedRoot, "dist"));
+    ignoredRoots.add(path58.join(normalizedRoot, "dist"));
   }
   if (configService?.outDir) {
-    ignoredRoots.add(path57.resolve(configService.cwd, configService.outDir));
+    ignoredRoots.add(path58.resolve(configService.cwd, configService.outDir));
   }
   return (candidate) => {
-    const normalized = path57.normalize(candidate);
+    const normalized = path58.normalize(candidate);
     for (const ignored of ignoredRoots) {
-      if (normalized === ignored || normalized.startsWith(`${ignored}${path57.sep}`)) {
+      if (normalized === ignored || normalized.startsWith(`${ignored}${path58.sep}`)) {
         return true;
       }
     }
@@ -29263,7 +29459,7 @@ function createBuildStartHook(state) {
           ensureSidecarWatcher(ctx, configService.absolutePluginRoot);
         }
       } else {
-        const rootDir = subPackageMeta ? path58.resolve(configService.absoluteSrcRoot, subPackageMeta.subPackage.root) : configService.absoluteSrcRoot;
+        const rootDir = subPackageMeta ? path59.resolve(configService.absoluteSrcRoot, subPackageMeta.subPackage.root) : configService.absoluteSrcRoot;
         ensureSidecarWatcher(ctx, rootDir);
         if (!subPackageMeta && configService.absolutePluginRoot) {
           ensureSidecarWatcher(ctx, configService.absolutePluginRoot);
@@ -29294,7 +29490,7 @@ function createWatchChangeHook(state) {
       }
       if (isTemplateFile2 || configSuffix || isStyleFile2) {
         const basePath = configSuffix ? normalizedId.slice(0, -configSuffix.length) : (() => {
-          const ext = path58.extname(normalizedId);
+          const ext = path59.extname(normalizedId);
           return ext ? normalizedId.slice(0, -ext.length) : normalizedId;
         })();
         const primaryScript = await findJsEntry(basePath);
@@ -29333,7 +29529,7 @@ function createWatchChangeHook(state) {
       let shouldMarkProjectConfigDirty = relativeCwd === projectConfigFileName || relativeCwd === projectPrivateConfigFileName;
       if (isMultiPlatformEnabled) {
         const projectConfigRoot = typeof multiPlatformConfig === "object" && multiPlatformConfig.projectConfigRoot?.trim() ? multiPlatformConfig.projectConfigRoot.trim() : "config";
-        const platformConfigDir = path58.join(projectConfigRoot, platform);
+        const platformConfigDir = path59.join(projectConfigRoot, platform);
         const platformConfigPrefix = `${platformConfigDir}/`;
         shouldMarkProjectConfigDirty = relativeCwd.startsWith(platformConfigPrefix);
       }
@@ -29383,7 +29579,7 @@ function createCoreLifecyclePlugin(state) {
 
 // src/plugins/core/requireAnalysis.ts
 init_esm_shims();
-import path59 from "pathe";
+import path60 from "pathe";
 
 // src/plugins/utils/ast.ts
 init_esm_shims();
@@ -29444,7 +29640,7 @@ function createRequireAnalysisPlugin(state) {
         return;
       }
       for (const requireModule of requireTokens) {
-        const absPath = path59.resolve(path59.dirname(moduleInfo.id), requireModule.value);
+        const absPath = path60.resolve(path60.dirname(moduleInfo.id), requireModule.value);
         const resolved = await this.resolve(absPath, moduleInfo.id);
         if (!resolved) {
           continue;
@@ -29538,11 +29734,11 @@ function weappVite(ctx, subPackageMeta) {
 // src/plugins/css.ts
 init_esm_shims();
 import fs28 from "fs-extra";
-import path61 from "pathe";
+import path62 from "pathe";
 
 // src/plugins/css/shared/sharedStyles.ts
 init_esm_shims();
-import path60 from "pathe";
+import path61 from "pathe";
 import picomatch2 from "picomatch";
 var styleMatcherCache = /* @__PURE__ */ new WeakMap();
 function collectSharedStyleEntries(ctx, configService) {
@@ -29651,7 +29847,7 @@ function findSharedStylesForModule(modulePath, fileName, sharedStyles) {
 }
 function resolveImportSpecifiers(fileName, entries) {
   const posixFileName = toPosixPath(fileName);
-  const dir = path60.posix.dirname(posixFileName);
+  const dir = path61.posix.dirname(posixFileName);
   const seen = /* @__PURE__ */ new Set();
   const specifiers = [];
   for (const entry of entries) {
@@ -29659,8 +29855,8 @@ function resolveImportSpecifiers(fileName, entries) {
     if (target === posixFileName) {
       continue;
     }
-    const relative3 = path60.posix.relative(dir, target);
-    let specifier = relative3 || path60.posix.basename(target);
+    const relative3 = path61.posix.relative(dir, target);
+    let specifier = relative3 || path61.posix.basename(target);
     if (!specifier || specifier === ".") {
       continue;
     }
@@ -29764,7 +29960,7 @@ async function handleBundleEntry(bundle, bundleKey, asset2, configService, share
   };
   if (bundleKey.endsWith(".wxss")) {
     const [rawOriginal] = asset2.originalFileNames ?? [];
-    const absOriginal = rawOriginal ? toAbsolute(rawOriginal) : path61.resolve(configService.absoluteSrcRoot, bundleKey);
+    const absOriginal = rawOriginal ? toAbsolute(rawOriginal) : path62.resolve(configService.absoluteSrcRoot, bundleKey);
     const fileName = configService.relativeOutputPath(absOriginal);
     if (fileName) {
       emitted.add(toPosixPath(fileName));
@@ -29983,7 +30179,7 @@ init_esm_shims();
 init_esm_shims();
 import { createRequire as createRequire8 } from "module";
 import process8 from "process";
-import path62 from "pathe";
+import path63 from "pathe";
 
 // src/plugins/vue/transform/styleRequest.ts
 init_esm_shims();
@@ -30073,7 +30269,7 @@ function ensureWevuInstalled(ctx) {
   }
   const configService = ctx.configService;
   const cwd = configService?.cwd ?? process8.cwd();
-  const require3 = createRequire8(path62.join(cwd, "package.json"));
+  const require3 = createRequire8(path63.join(cwd, "package.json"));
   try {
     require3.resolve("wevu");
     wevuInstallState = "present";
@@ -30162,7 +30358,7 @@ init_esm_shims();
 // src/plugins/vue/transform/plugin.ts
 init_esm_shims();
 import fs33 from "fs-extra";
-import path67 from "pathe";
+import path68 from "pathe";
 import { compileJsxFile as compileJsxFile2, compileVueFile as compileVueFile2 } from "wevu/compiler";
 
 // src/plugins/performance/onPageScrollDiagnostics.ts
@@ -30300,52 +30496,52 @@ function collectOnPageScrollPerformanceWarnings(code, filename) {
     }
   };
   traverse(ast, {
-    ObjectMethod(path81) {
-      const keyName = isStaticPropertyName(path81.node.key);
+    ObjectMethod(path82) {
+      const keyName = isStaticPropertyName(path82.node.key);
       if (keyName !== "onPageScroll") {
         return;
       }
-      reportInspection(path81, path81.node, "onPageScroll");
+      reportInspection(path82, path82.node, "onPageScroll");
     },
-    ObjectProperty(path81) {
-      if (path81.node.computed) {
+    ObjectProperty(path82) {
+      if (path82.node.computed) {
         return;
       }
-      const keyName = isStaticPropertyName(path81.node.key);
+      const keyName = isStaticPropertyName(path82.node.key);
       if (keyName !== "onPageScroll") {
         return;
       }
-      const value = path81.node.value;
+      const value = path82.node.value;
       if (value.type !== "FunctionExpression" && value.type !== "ArrowFunctionExpression") {
         return;
       }
-      reportInspection(path81.get("value"), value, "onPageScroll");
+      reportInspection(path82.get("value"), value, "onPageScroll");
     },
-    CallExpression(path81) {
-      if (!isOnPageScrollCallee(path81.node.callee, onPageScrollHookNames, namespaceImports)) {
+    CallExpression(path82) {
+      if (!isOnPageScrollCallee(path82.node.callee, onPageScrollHookNames, namespaceImports)) {
         return;
       }
-      const arg0 = path81.node.arguments[0];
+      const arg0 = path82.node.arguments[0];
       if (!arg0 || arg0.type === "SpreadElement") {
         return;
       }
       if (arg0.type !== "FunctionExpression" && arg0.type !== "ArrowFunctionExpression") {
         return;
       }
-      reportInspection(path81.get("arguments.0"), arg0, "onPageScroll(...)");
+      reportInspection(path82.get("arguments.0"), arg0, "onPageScroll(...)");
     },
-    OptionalCallExpression(path81) {
-      if (!isOnPageScrollCallee(path81.node.callee, onPageScrollHookNames, namespaceImports)) {
+    OptionalCallExpression(path82) {
+      if (!isOnPageScrollCallee(path82.node.callee, onPageScrollHookNames, namespaceImports)) {
         return;
       }
-      const arg0 = path81.node.arguments[0];
+      const arg0 = path82.node.arguments[0];
       if (!arg0 || arg0.type === "SpreadElement") {
         return;
       }
       if (arg0.type !== "FunctionExpression" && arg0.type !== "ArrowFunctionExpression") {
         return;
       }
-      reportInspection(path81.get("arguments.0"), arg0, "onPageScroll(...)");
+      reportInspection(path82.get("arguments.0"), arg0, "onPageScroll(...)");
     }
   });
   return warnings;
@@ -30353,7 +30549,7 @@ function collectOnPageScrollPerformanceWarnings(code, filename) {
 
 // src/plugins/wevu.ts
 init_esm_shims();
-import path63 from "pathe";
+import path64 from "pathe";
 import {
   createPageEntryMatcher,
   injectWevuPageFeaturesInJsWithResolver
@@ -30433,7 +30629,7 @@ function createWevuAutoPageFeaturesPlugin(ctx) {
         return null;
       }
       const filename = toAbsoluteId(sourceId, configService, void 0, { base: "cwd" });
-      if (!filename || !path63.isAbsolute(filename)) {
+      if (!filename || !path64.isAbsolute(filename)) {
         return null;
       }
       if (!await pageMatcher.isPageFile(filename)) {
@@ -33213,7 +33409,7 @@ function scanWxml(wxml, options) {
 
 // src/plugins/vue/transform/classStyle.ts
 init_esm_shims();
-import path64 from "pathe";
+import path65 from "pathe";
 import { resolveClassStyleWxsLocation } from "wevu/compiler";
 function resolveClassStylePackageRoot(ctx, relativeBase, configService) {
   const currentRoot = normalizeRoot(configService.currentSubPackageRoot ?? "");
@@ -33239,7 +33435,7 @@ function resolveClassStylePackageRoot(ctx, relativeBase, configService) {
 function resolveClassStyleWxsLocationForBase(ctx, relativeBase, extension, configService) {
   const classStyleWxsShared = configService.weappViteConfig?.vue?.template?.classStyleWxsShared ?? true;
   const packageRoot = classStyleWxsShared ? resolveClassStylePackageRoot(ctx, relativeBase, configService) : (() => {
-    const dir = path64.posix.dirname(toPosixPath(relativeBase));
+    const dir = path65.posix.dirname(toPosixPath(relativeBase));
     return dir === "." ? "" : dir;
   })();
   return resolveClassStyleWxsLocation({ relativeBase, extension, packageRoot });
@@ -33566,12 +33762,12 @@ function emitClassStyleWxsAssetIfMissing(ctx, bundle, fileName, source) {
 // src/plugins/vue/transform/fallbackEntries.ts
 init_esm_shims();
 import fs31 from "fs-extra";
-import path66 from "pathe";
+import path67 from "pathe";
 
 // src/plugins/vue/transform/collectVuePages.ts
 init_esm_shims();
 import fs30 from "fs-extra";
-import path65 from "pathe";
+import path66 from "pathe";
 var VUE_LIKE_EXTENSIONS2 = [".vue", ".tsx", ".jsx"];
 function isVueLikeFile2(file) {
   return VUE_LIKE_EXTENSIONS2.some((ext) => file.endsWith(ext));
@@ -33589,7 +33785,7 @@ async function collectVuePages(root) {
   try {
     const entries = await fs30.readdir(root);
     for (const entry of entries) {
-      const full = path65.join(root, entry);
+      const full = path66.join(root, entry);
       const stat5 = await fs30.stat(full);
       if (stat5.isDirectory()) {
         const nested = await collectVuePages(full);
@@ -33609,7 +33805,7 @@ async function collectFallbackPageEntryIds(configService, scanService) {
   if (scanService?.appEntry?.json?.pages?.length) {
     pageList = scanService.appEntry.json.pages;
   } else {
-    const appJsonPath = path66.join(configService.cwd, "dist", "app.json");
+    const appJsonPath = path67.join(configService.cwd, "dist", "app.json");
     try {
       const appJsonContent = await fs31.readFile(appJsonPath, "utf-8");
       const appJson = JSON.parse(appJsonContent);
@@ -33618,8 +33814,8 @@ async function collectFallbackPageEntryIds(configService, scanService) {
     }
   }
   const collectedEntries = /* @__PURE__ */ new Set();
-  pageList.forEach((p) => collectedEntries.add(path66.join(configService.absoluteSrcRoot, p)));
-  const extraVueFiles = await collectVuePages(path66.join(configService.absoluteSrcRoot, "pages"));
+  pageList.forEach((p) => collectedEntries.add(path67.join(configService.absoluteSrcRoot, p)));
+  const extraVueFiles = await collectVuePages(path67.join(configService.absoluteSrcRoot, "pages"));
   extraVueFiles.forEach((f) => collectedEntries.add(f.slice(0, -4)));
   return collectedEntries;
 }
@@ -33879,15 +34075,15 @@ function collectIdentifiersFromExpression(expression) {
     return collected;
   }
   traverse(ast, {
-    Identifier(path81) {
-      if (!path81.isReferencedIdentifier()) {
+    Identifier(path82) {
+      if (!path82.isReferencedIdentifier()) {
         return;
       }
-      const name = path81.node.name;
+      const name = path82.node.name;
       if (name === "__weappViteExpr") {
         return;
       }
-      if (path81.scope.hasBinding(name, true)) {
+      if (path82.scope.hasBinding(name, true)) {
         return;
       }
       if (JS_GLOBAL_IDENTIFIERS.has(name)) {
@@ -33895,15 +34091,15 @@ function collectIdentifiersFromExpression(expression) {
       }
       collected.add(name);
     },
-    MemberExpression(path81) {
-      const member = path81.node;
+    MemberExpression(path82) {
+      const member = path82.node;
       if (member.computed || member.object.type !== "ThisExpression" || member.property.type !== "Identifier") {
         return;
       }
       collected.add(member.property.name);
     },
-    OptionalMemberExpression(path81) {
-      const member = path81.node;
+    OptionalMemberExpression(path82) {
+      const member = path82.node;
       if (member.computed || member.object.type !== "ThisExpression" || member.property.type !== "Identifier") {
         return;
       }
@@ -33936,15 +34132,15 @@ function injectSetDataPickInJs(source, pickKeys) {
   const ast = parseJsLike(source);
   const candidateOptions = /* @__PURE__ */ new Set();
   traverse(ast, {
-    CallExpression(path81) {
-      if (!isTargetWevuComponentCall(path81.node.callee)) {
+    CallExpression(path82) {
+      if (!isTargetWevuComponentCall(path82.node.callee)) {
         return;
       }
-      const firstArg = path81.node.arguments[0];
+      const firstArg = path82.node.arguments[0];
       if (!firstArg || firstArg.type === "SpreadElement") {
         return;
       }
-      const resolvedOptions = resolveOptionsObjectExpression2(firstArg, path81.scope);
+      const resolvedOptions = resolveOptionsObjectExpression2(firstArg, path82.scope);
       if (resolvedOptions) {
         candidateOptions.add(resolvedOptions);
       }
@@ -34634,7 +34830,7 @@ function createVueTransformPlugin(ctx) {
       }
       const sourceId = getSourceFromVirtualId(id);
       const filename = toAbsoluteId(sourceId, configService, void 0, { base: "cwd" });
-      if (!filename || !path67.isAbsolute(filename)) {
+      if (!filename || !path68.isAbsolute(filename)) {
         return null;
       }
       if (typeof this.addWatchFile === "function") {
@@ -34877,12 +35073,12 @@ init_esm_shims();
 import { createHash as createHash3 } from "crypto";
 import { removeExtension as removeExtension2 } from "@weapp-core/shared";
 import fs34 from "fs-extra";
-import path68 from "pathe";
+import path69 from "pathe";
 async function resolveWorkerEntry(ctx, entry) {
   const { configService, scanService } = ctx;
-  const relativeEntryPath = path68.join(scanService.workersDir, entry);
+  const relativeEntryPath = path69.join(scanService.workersDir, entry);
   const key = removeExtension2(relativeEntryPath);
-  const absoluteEntry = path68.resolve(configService.absoluteSrcRoot, relativeEntryPath);
+  const absoluteEntry = path69.resolve(configService.absoluteSrcRoot, relativeEntryPath);
   if (isJsOrTs(entry)) {
     const exists = await fs34.pathExists(absoluteEntry);
     if (!exists) {
@@ -34919,12 +35115,12 @@ function createWorkerBuildPlugin(ctx) {
       options.chunkFileNames = (chunkInfo) => {
         const workersDir = scanService.workersDir ?? "";
         if (chunkInfo.isDynamicEntry) {
-          return path68.join(workersDir, "[name].js");
+          return path69.join(workersDir, "[name].js");
         }
         const sourceId = chunkInfo.facadeModuleId ?? chunkInfo.moduleIds[0];
         const hashBase = typeof sourceId === "string" ? configService.relativeCwd(sourceId) : chunkInfo.name;
         const stableHash = createHash3("sha256").update(hashBase).digest("base64url").slice(0, 8);
-        return path68.join(workersDir, `${chunkInfo.name}-${stableHash}.js`);
+        return path69.join(workersDir, `${chunkInfo.name}-${stableHash}.js`);
       };
     }
   };
@@ -34940,7 +35136,7 @@ function workers(ctx) {
 init_esm_shims();
 import { removeExtension as removeExtension3 } from "@weapp-core/shared";
 import fs35 from "fs-extra";
-import path69 from "pathe";
+import path70 from "pathe";
 var wxsCodeCache = new L({
   max: 512
 });
@@ -34967,13 +35163,13 @@ async function transformWxsFile(state, wxsPath) {
     if (typeof result?.code === "string") {
       code = result.code;
     }
-    const dirname5 = path69.dirname(wxsPath);
+    const dirname5 = path70.dirname(wxsPath);
     await Promise.all(
       importees.map(({ source }) => {
         return transformWxsFile.call(
           this,
           state,
-          path69.resolve(dirname5, source)
+          path70.resolve(dirname5, source)
         );
       })
     );
@@ -35001,7 +35197,7 @@ async function handleWxsDeps(state, deps, absPath) {
       if (!jsExtensions.includes(dep.attrs.lang) && !arr) {
         return;
       }
-      const wxsPath = path69.resolve(path69.dirname(absPath), dep.value);
+      const wxsPath = path70.resolve(path70.dirname(absPath), dep.value);
       await transformWxsFile.call(this, state, wxsPath);
     })
   );
@@ -35023,7 +35219,7 @@ async function handleWxsDepsFromBundle(state, bundle) {
       } catch {
         return;
       }
-      const absPath = path69.resolve(state.ctx.configService.absoluteSrcRoot, fileName);
+      const absPath = path70.resolve(state.ctx.configService.absoluteSrcRoot, fileName);
       await handleWxsDeps.call(this, state, deps, absPath);
     })
   );
@@ -35167,6 +35363,7 @@ function arrangePlugins(config, ctx, subPackageMeta) {
 }
 
 // src/runtime/config/internal/merge/miniprogram.ts
+var PACKAGE_NAME_REGEX = /[-/\\^$*+?.()|[\]{}]/g;
 function mergeMiniprogram(options, ...configs) {
   const {
     ctx,
@@ -35188,7 +35385,7 @@ function mergeMiniprogram(options, ...configs) {
   if (packageJson?.dependencies) {
     external.push(
       ...Object.keys(packageJson.dependencies).map((pkg) => {
-        return new RegExp(`^${pkg.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}(\\/|$)`);
+        return new RegExp(`^${pkg.replace(PACKAGE_NAME_REGEX, "\\$&")}(\\/|$)`);
       })
     );
   }
@@ -35203,17 +35400,17 @@ function mergeMiniprogram(options, ...configs) {
   };
   if (isDev) {
     const watchInclude = [
-      path70.join(cwd, srcRoot, "**")
+      path71.join(cwd, srcRoot, "**")
     ];
     const pluginRootConfig = config.weapp?.pluginRoot;
     if (pluginRootConfig) {
-      const absolutePluginRoot = path70.resolve(cwd, pluginRootConfig);
-      const relativeToSrc = path70.relative(
-        path70.resolve(cwd, srcRoot),
+      const absolutePluginRoot = path71.resolve(cwd, pluginRootConfig);
+      const relativeToSrc = path71.relative(
+        path71.resolve(cwd, srcRoot),
         absolutePluginRoot
       );
-      const pluginPatternBase = relativeToSrc.startsWith("..") ? absolutePluginRoot : path70.join(cwd, srcRoot, relativeToSrc);
-      watchInclude.push(path70.join(pluginPatternBase, "**"));
+      const pluginPatternBase = relativeToSrc.startsWith("..") ? absolutePluginRoot : path71.join(cwd, srcRoot, relativeToSrc);
+      watchInclude.push(path71.join(pluginPatternBase, "**"));
     }
     const inline = defu5(
       config,
@@ -35227,7 +35424,7 @@ function mergeMiniprogram(options, ...configs) {
           watch: {
             exclude: [
               ...defaultExcluded,
-              mpDistRoot ? path70.join(cwd, mpDistRoot, "**") : path70.join(cwd, "dist", "**")
+              mpDistRoot ? path71.join(cwd, mpDistRoot, "**") : path71.join(cwd, "dist", "**")
             ],
             include: watchInclude
           },
@@ -35245,6 +35442,7 @@ function mergeMiniprogram(options, ...configs) {
       ...inline.define ?? {},
       __VITE_IS_MODERN__: "false"
     };
+    applyWeappViteHostMeta(inline, "miniprogram");
     stripRollupOptions(inline);
     arrangePlugins(inline, ctx, subPackageMeta);
     injectBuiltinAliases(inline);
@@ -35271,6 +35469,7 @@ function mergeMiniprogram(options, ...configs) {
     ...inlineConfig.define ?? {},
     __VITE_IS_MODERN__: "false"
   };
+  applyWeappViteHostMeta(inlineConfig, "miniprogram");
   stripRollupOptions(inlineConfig);
   arrangePlugins(inlineConfig, ctx, subPackageMeta);
   inlineConfig.logLevel = "info";
@@ -35344,9 +35543,8 @@ function mergeWeb(options, ...configs) {
   inline.plugins = mergedPlugins;
   inline.build ??= {};
   inline.build.outDir = web.outDir;
-  if (inline.build.emptyOutDir == null) {
-    inline.build.emptyOutDir = !isDev;
-  }
+  inline.build.emptyOutDir ??= !isDev;
+  applyWeappViteHostMeta(inline, "web");
   inline.define = defu6(inline.define ?? {}, getDefineImportMetaEnv());
   injectBuiltinAliases(inline);
   return inline;
@@ -35382,6 +35580,7 @@ function mergeWorkers(options, ...configs) {
         }
       }
     );
+    applyWeappViteHostMeta(inline, "miniprogram");
     stripRollupOptions(inline);
     injectBuiltinAliases(inline);
     return inline;
@@ -35399,6 +35598,7 @@ function mergeWorkers(options, ...configs) {
       }
     }
   );
+  applyWeappViteHostMeta(inlineConfig, "miniprogram");
   stripRollupOptions(inlineConfig);
   inlineConfig.logLevel = "info";
   injectBuiltinAliases(inlineConfig);
@@ -35501,14 +35701,14 @@ function createConfigService(ctx) {
     if (!pluginRootConfig) {
       return void 0;
     }
-    return path71.resolve(options.cwd, pluginRootConfig);
+    return path72.resolve(options.cwd, pluginRootConfig);
   };
   const resolvePluginSourceBase = () => {
     const absolutePluginRoot = resolveAbsolutePluginRoot();
     if (!absolutePluginRoot) {
       return void 0;
     }
-    return toPosixPath(path71.basename(absolutePluginRoot));
+    return toPosixPath(path72.basename(absolutePluginRoot));
   };
   const resolveAbsolutePluginOutputRoot = () => {
     const absolutePluginRoot = resolveAbsolutePluginRoot();
@@ -35517,19 +35717,19 @@ function createConfigService(ctx) {
     }
     const configured = options.projectConfig?.pluginRoot;
     if (configured) {
-      return path71.resolve(options.cwd, configured);
+      return path72.resolve(options.cwd, configured);
     }
-    const outDir = path71.resolve(options.cwd, options.mpDistRoot ?? "");
-    const pluginBase = path71.basename(absolutePluginRoot);
-    return path71.resolve(outDir, pluginBase);
+    const outDir = path72.resolve(options.cwd, options.mpDistRoot ?? "");
+    const pluginBase = path72.basename(absolutePluginRoot);
+    return path72.resolve(outDir, pluginBase);
   };
   const resolvePluginOutputBasePosix = () => {
     const absoluteOutputRoot = resolveAbsolutePluginOutputRoot();
     if (!absoluteOutputRoot) {
       return void 0;
     }
-    const outDir = path71.resolve(options.cwd, options.mpDistRoot ?? "");
-    const normalized = normalizeRelativePath(path71.relative(outDir, absoluteOutputRoot));
+    const outDir = path72.resolve(options.cwd, options.mpDistRoot ?? "");
+    const normalized = normalizeRelativePath(path72.relative(outDir, absoluteOutputRoot));
     if (!normalized || normalized === ".") {
       return resolvePluginSourceBase();
     }
@@ -35665,7 +35865,7 @@ function createConfigService(ctx) {
       return options.mpDistRoot;
     },
     get outDir() {
-      return path71.resolve(options.cwd, options.mpDistRoot ?? "");
+      return path72.resolve(options.cwd, options.mpDistRoot ?? "");
     },
     get currentSubPackageRoot() {
       return options.currentSubPackageRoot;
@@ -35701,7 +35901,7 @@ function createConfigService(ctx) {
       return resolveAbsolutePluginOutputRoot();
     },
     get absoluteSrcRoot() {
-      return path71.resolve(options.cwd, options.srcRoot);
+      return path72.resolve(options.cwd, options.srcRoot);
     },
     get mode() {
       return options.mode;
@@ -35725,27 +35925,27 @@ function createConfigService(ctx) {
       return options.weappLibOutputMap;
     },
     relativeCwd(p) {
-      return normalizeRelativePath(path71.relative(options.cwd, p));
+      return normalizeRelativePath(path72.relative(options.cwd, p));
     },
     relativeSrcRoot(p) {
       return options.relativeSrcRoot(p);
     },
     relativeAbsoluteSrcRoot(p) {
-      const absoluteSrcRoot = path71.resolve(options.cwd, options.srcRoot);
+      const absoluteSrcRoot = path72.resolve(options.cwd, options.srcRoot);
       const absolutePluginRoot = resolveAbsolutePluginRoot();
       if (absolutePluginRoot) {
-        const relativeToPlugin = normalizeRelativePath(path71.relative(absolutePluginRoot, p));
+        const relativeToPlugin = normalizeRelativePath(path72.relative(absolutePluginRoot, p));
         if (!relativeToPlugin.startsWith("..")) {
-          const pluginBase = path71.basename(absolutePluginRoot);
+          const pluginBase = path72.basename(absolutePluginRoot);
           const posixBase = toPosixPath(pluginBase);
           return relativeToPlugin ? `${posixBase}/${relativeToPlugin}` : posixBase;
         }
       }
-      const relativeFromSrc = normalizeRelativePath(path71.relative(absoluteSrcRoot, p));
+      const relativeFromSrc = normalizeRelativePath(path72.relative(absoluteSrcRoot, p));
       if (!relativeFromSrc.startsWith("..")) {
         return relativeFromSrc;
       }
-      const relativeFromCwd = normalizeRelativePath(path71.relative(options.cwd, p));
+      const relativeFromCwd = normalizeRelativePath(path72.relative(options.cwd, p));
       return relativeFromCwd;
     },
     relativeOutputPath(p) {
@@ -35758,7 +35958,7 @@ function createConfigService(ctx) {
         const base = normalizeRelativePath(removeExtensionDeep13(relative3));
         const mapped = libOutputMap.get(base);
         if (mapped) {
-          const ext = path71.extname(relative3);
+          const ext = path72.extname(relative3);
           const fileName = ext ? `${mapped}${ext}` : mapped;
           return remapPluginRelativePath(fileName);
         }
@@ -35884,7 +36084,7 @@ init_esm_shims();
 // src/runtime/npmPlugin/service.ts
 init_esm_shims();
 import fs39 from "fs-extra";
-import path75 from "pathe";
+import path76 from "pathe";
 
 // src/runtime/npmPlugin/builder.ts
 init_esm_shims();
@@ -35893,13 +36093,27 @@ import process11 from "process";
 import * as t2 from "@babel/types";
 import { defu as defu9, isObject as isObject10 } from "@weapp-core/shared";
 import fs37 from "fs-extra";
-import path72 from "pathe";
+import path73 from "pathe";
 import { build as viteBuild } from "vite";
 var ALIPAY_EXTENSION_MAP = {
   ".wxml": ".axml",
   ".wxss": ".acss",
   ".wxs": ".sjs"
 };
+var WX_TEMPLATE_REFERENCE_RE = /\.wxml\b|\.wxss\b|\.wxs\b/;
+var ESM_SYNTAX_RE = /\bimport\s|\bexport\s/;
+var NULLISH_COALESCING_RE = /\?\?/;
+var WX_DIRECTIVE_RE = /\bwx:(?:if|elif|else|for|for-item|for-index|key)\b/;
+var WX_DIRECTIVE_CAPTURE_RE = /\bwx:(if|elif|else|for|for-item|for-index|key)\b/g;
+var WXS_TAG_RE = /<\s*(?:\/\s*)?wxs\b/;
+var WXS_CLOSING_TAG_RE = /<\s*\/\s*wxs\b/g;
+var ELSE_ATTRIBUTE_RE = /\selse(?=[\s/>])/;
+var IMPORT_SJS_TAG_RE = /<import-sjs([\s\S]*?)>/g;
+var SRC_ATTRIBUTE_RE = /\bsrc\s*=\s*/g;
+var MODULE_ATTRIBUTE_RE = /\bmodule\s*=\s*/g;
+var WXML_EXTENSION_RE = /\.wxml\b/g;
+var WXSS_EXTENSION_RE = /\.wxss\b/g;
+var WXS_EXTENSION_RE = /\.wxs\b/g;
 var ALIPAY_TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".js",
   ".json",
@@ -35920,7 +36134,7 @@ async function collectFiles(root) {
     }
     const entries = await fs37.readdir(current2, { withFileTypes: true });
     for (const entry of entries) {
-      const filePath = path72.resolve(current2, entry.name);
+      const filePath = path73.resolve(current2, entry.name);
       if (entry.isDirectory()) {
         stack.push(filePath);
       } else if (entry.isFile()) {
@@ -35935,15 +36149,15 @@ async function shouldRebuildCachedAlipayMiniprogramPackage(pkgRoot, outDir, sour
     return true;
   }
   if (sourceRoot && alipayNpmDistDirName === "node_modules") {
-    const sourceEsRoot = path72.resolve(sourceRoot, "es");
-    const targetEsRoot = path72.resolve(pkgRoot, "es");
+    const sourceEsRoot = path73.resolve(sourceRoot, "es");
+    const targetEsRoot = path73.resolve(pkgRoot, "es");
     if (await fs37.pathExists(sourceEsRoot) && !await fs37.pathExists(targetEsRoot)) {
       return true;
     }
   }
   const files = await collectFiles(pkgRoot);
   for (const filePath of files) {
-    const ext = path72.extname(filePath);
+    const ext = path73.extname(filePath);
     if (ext === ".wxml" || ext === ".wxss" || ext === ".wxs") {
       return true;
     }
@@ -35956,23 +36170,23 @@ async function shouldRebuildCachedAlipayMiniprogramPackage(pkgRoot, outDir, sour
     } catch {
       continue;
     }
-    if (/\.wxml\b|\.wxss\b|\.wxs\b/.test(source)) {
+    if (WX_TEMPLATE_REFERENCE_RE.test(source)) {
       return true;
     }
-    if (ext === ".js" && (/\bimport\s|\bexport\s/.test(source) || /\?\?/.test(source))) {
+    if (ext === ".js" && (ESM_SYNTAX_RE.test(source) || NULLISH_COALESCING_RE.test(source))) {
       return true;
     }
-    if ((ext === ".axml" || ext === ".wxml") && (/\bwx:(?:if|elif|else|for|for-item|for-index|key)\b/.test(source) || /<\s*(?:\/\s*)?wxs\b/.test(source) || /\selse(?=[\s/>])/.test(source))) {
+    if ((ext === ".axml" || ext === ".wxml") && (WX_DIRECTIVE_RE.test(source) || WXS_TAG_RE.test(source) || ELSE_ATTRIBUTE_RE.test(source))) {
       return true;
     }
   }
-  const nestedRoot = path72.resolve(pkgRoot, "miniprogram_npm");
+  const nestedRoot = path73.resolve(pkgRoot, "miniprogram_npm");
   if (!await fs37.pathExists(nestedRoot)) {
     return false;
   }
   const entries = await fs37.readdir(nestedRoot);
   for (const name of entries) {
-    const target = path72.resolve(outDir, name);
+    const target = path73.resolve(outDir, name);
     if (!await fs37.pathExists(target)) {
       return true;
     }
@@ -35980,15 +36194,15 @@ async function shouldRebuildCachedAlipayMiniprogramPackage(pkgRoot, outDir, sour
   return false;
 }
 function hasEsmSyntax(source) {
-  return /\bimport\s|\bexport\s/.test(source);
+  return ESM_SYNTAX_RE.test(source);
 }
 function rewriteAlipayWxmlSyntax(source) {
-  return source.replace(/\bwx:(if|elif|else|for|for-item|for-index|key)\b/g, (_2, directive) => `a:${directive}`).replace(/<\s*\/\s*wxs\b/g, "</import-sjs").replace(/<\s*wxs\b/g, "<import-sjs").replace(/<import-sjs([\s\S]*?)>/g, (tag) => {
-    return tag.replace(/\bsrc\s*=\s*/g, "from=").replace(/\bmodule\s*=\s*/g, "name=");
-  }).replace(/\selse(?=[\s/>])/g, " a:else");
+  return source.replace(WX_DIRECTIVE_CAPTURE_RE, (_2, directive) => `a:${directive}`).replace(WXS_CLOSING_TAG_RE, "</import-sjs").replace(WXS_TAG_RE, "<import-sjs").replace(IMPORT_SJS_TAG_RE, (tag) => {
+    return tag.replace(SRC_ATTRIBUTE_RE, "from=").replace(MODULE_ATTRIBUTE_RE, "name=");
+  }).replace(ELSE_ATTRIBUTE_RE, " a:else");
 }
 function rewriteAlipayExtensionReferences(source) {
-  return source.replace(/\.wxml\b/g, ".axml").replace(/\.wxss\b/g, ".acss").replace(/\.wxs\b/g, ".sjs");
+  return source.replace(WXML_EXTENSION_RE, ".axml").replace(WXSS_EXTENSION_RE, ".acss").replace(WXS_EXTENSION_RE, ".sjs");
 }
 function transformWxmlToAxmlForAlipay(source) {
   return rewriteAlipayWxmlSyntax(source);
@@ -36028,11 +36242,11 @@ async function transformJsModuleToCjsForAlipay(source) {
     let transformed = false;
     const exportAssignments = [];
     traverse(ast, {
-      ImportDeclaration(path81) {
-        const sourceLiteral = t2.stringLiteral(path81.node.source.value);
-        const specifiers = path81.node.specifiers ?? [];
+      ImportDeclaration(path82) {
+        const sourceLiteral = t2.stringLiteral(path82.node.source.value);
+        const specifiers = path82.node.specifiers ?? [];
         if (specifiers.length === 0) {
-          path81.replaceWith(
+          path82.replaceWith(
             t2.expressionStatement(
               t2.callExpression(t2.identifier("require"), [sourceLiteral])
             )
@@ -36040,7 +36254,7 @@ async function transformJsModuleToCjsForAlipay(source) {
           transformed = true;
           return;
         }
-        const requireId = path81.scope.generateUidIdentifier("imported");
+        const requireId = path82.scope.generateUidIdentifier("imported");
         const statements = [
           t2.variableDeclaration("const", [
             t2.variableDeclarator(
@@ -36087,23 +36301,23 @@ async function transformJsModuleToCjsForAlipay(source) {
             ])
           );
         }
-        path81.replaceWithMultiple(statements);
+        path82.replaceWithMultiple(statements);
         transformed = true;
       },
-      ExportDefaultDeclaration(path81) {
-        const declaration = path81.node.declaration;
+      ExportDefaultDeclaration(path82) {
+        const declaration = path82.node.declaration;
         if (t2.isFunctionDeclaration(declaration) || t2.isClassDeclaration(declaration)) {
-          const exportId = declaration.id ?? path81.scope.generateUidIdentifier("defaultExport");
+          const exportId = declaration.id ?? path82.scope.generateUidIdentifier("defaultExport");
           if (!declaration.id) {
             declaration.id = exportId;
           }
-          path81.replaceWith(declaration);
+          path82.replaceWith(declaration);
           exportAssignments.push(createExportsAssignment("default", exportId));
           transformed = true;
           return;
         }
-        const targetId = path81.scope.generateUidIdentifier("defaultExport");
-        path81.replaceWith(
+        const targetId = path82.scope.generateUidIdentifier("defaultExport");
+        path82.replaceWith(
           t2.variableDeclaration("const", [
             t2.variableDeclarator(targetId, declaration)
           ])
@@ -36111,10 +36325,10 @@ async function transformJsModuleToCjsForAlipay(source) {
         exportAssignments.push(createExportsAssignment("default", targetId));
         transformed = true;
       },
-      ExportNamedDeclaration(path81) {
-        const declaration = path81.node.declaration;
+      ExportNamedDeclaration(path82) {
+        const declaration = path82.node.declaration;
         if (declaration) {
-          path81.replaceWith(declaration);
+          path82.replaceWith(declaration);
           const names = Object.keys(t2.getBindingIdentifiers(declaration));
           for (const name of names) {
             exportAssignments.push(createExportsAssignment(name, t2.identifier(name)));
@@ -36122,19 +36336,19 @@ async function transformJsModuleToCjsForAlipay(source) {
           transformed = true;
           return;
         }
-        const specifiers = path81.node.specifiers ?? [];
+        const specifiers = path82.node.specifiers ?? [];
         if (specifiers.length === 0) {
-          path81.remove();
+          path82.remove();
           transformed = true;
           return;
         }
-        if (path81.node.source) {
-          const requireId = path81.scope.generateUidIdentifier("reExported");
+        if (path82.node.source) {
+          const requireId = path82.scope.generateUidIdentifier("reExported");
           const statements2 = [
             t2.variableDeclaration("const", [
               t2.variableDeclarator(
                 requireId,
-                t2.callExpression(t2.identifier("require"), [t2.stringLiteral(path81.node.source.value)])
+                t2.callExpression(t2.identifier("require"), [t2.stringLiteral(path82.node.source.value)])
               )
             ])
           ];
@@ -36146,7 +36360,7 @@ async function transformJsModuleToCjsForAlipay(source) {
             const exportedName = getModuleExportName(specifier.exported);
             statements2.push(createExportsAssignment(exportedName, createRequireMemberExpression(requireId, localName)));
           }
-          path81.replaceWithMultiple(statements2);
+          path82.replaceWithMultiple(statements2);
           transformed = true;
           return;
         }
@@ -36159,7 +36373,7 @@ async function transformJsModuleToCjsForAlipay(source) {
           const exportedName = getModuleExportName(specifier.exported);
           statements.push(createExportsAssignment(exportedName, t2.identifier(localName)));
         }
-        path81.replaceWithMultiple(statements);
+        path82.replaceWithMultiple(statements);
         transformed = true;
       }
     });
@@ -36181,7 +36395,7 @@ async function normalizeMiniprogramPackageForAlipay(pkgRoot) {
   }
   const initialFiles = await collectFiles(pkgRoot);
   const renameTasks = initialFiles.map((filePath) => {
-    const ext = path72.extname(filePath);
+    const ext = path73.extname(filePath);
     const nextExt = ALIPAY_EXTENSION_MAP[ext];
     if (!nextExt) {
       return null;
@@ -36199,7 +36413,7 @@ async function normalizeMiniprogramPackageForAlipay(pkgRoot) {
   }
   const normalizedFiles = await collectFiles(pkgRoot);
   for (const filePath of normalizedFiles) {
-    const ext = path72.extname(filePath);
+    const ext = path73.extname(filePath);
     if (!ALIPAY_TEXT_FILE_EXTENSIONS.has(ext)) {
       continue;
     }
@@ -36218,14 +36432,14 @@ async function normalizeMiniprogramPackageForAlipay(pkgRoot) {
   }
 }
 async function hoistNestedMiniprogramDependenciesForAlipay(pkgRoot, outDir) {
-  const nestedRoot = path72.resolve(pkgRoot, "miniprogram_npm");
+  const nestedRoot = path73.resolve(pkgRoot, "miniprogram_npm");
   if (!await fs37.pathExists(nestedRoot)) {
     return;
   }
   const entries = await fs37.readdir(nestedRoot);
   for (const name of entries) {
-    const source = path72.resolve(nestedRoot, name);
-    const target = path72.resolve(outDir, name);
+    const source = path73.resolve(nestedRoot, name);
+    const target = path73.resolve(outDir, name);
     if (await fs37.pathExists(target)) {
       continue;
     }
@@ -36237,11 +36451,11 @@ async function hoistNestedMiniprogramDependenciesForAlipay(pkgRoot, outDir) {
   }
 }
 async function copyEsModuleDirectoryForAlipay(sourceRoot, targetRoot) {
-  const sourceDir = path72.resolve(sourceRoot, "es");
+  const sourceDir = path73.resolve(sourceRoot, "es");
   if (!await fs37.pathExists(sourceDir)) {
     return false;
   }
-  await fs37.copy(sourceDir, path72.resolve(targetRoot, "es"), {
+  await fs37.copy(sourceDir, path73.resolve(targetRoot, "es"), {
     overwrite: true
   });
   return true;
@@ -36255,7 +36469,18 @@ function createPackageBuilder(ctx, oxcVitePlugin) {
   async function shouldSkipBuild(outDir, isOutdated) {
     return !isOutdated && await fs37.pathExists(outDir);
   }
-  async function bundleBuild({ entry, name, options, outDir }) {
+  function resolveBuildOutDir(options, fallbackOutDir) {
+    const rawOutDir = options?.build?.outDir;
+    if (typeof rawOutDir !== "string" || !rawOutDir.trim()) {
+      return fallbackOutDir;
+    }
+    if (path73.isAbsolute(rawOutDir)) {
+      return rawOutDir;
+    }
+    const root = typeof options.root === "string" && options.root ? options.root : ctx.configService?.cwd ?? process11.cwd();
+    return path73.resolve(root, rawOutDir);
+  }
+  function resolvePackageBuildTarget({ entry, name, options, outDir }) {
     const defineImportMetaEnv = ctx.configService?.defineImportMetaEnv ?? {};
     const mergedOptions = defu9(options, {
       configFile: false,
@@ -36296,34 +36521,50 @@ function createPackageBuilder(ctx, oxcVitePlugin) {
     } else if (isObject10(resolvedOptions)) {
       finalOptions = resolvedOptions;
     }
-    if (finalOptions) {
-      if (oxcVitePlugin) {
-        const toPluginArray = (plugins) => {
-          const queue = [];
-          const result = [];
-          if (plugins) {
-            queue.push(plugins);
+    return {
+      outDir: resolveBuildOutDir(finalOptions ?? mergedOptions, outDir),
+      options: finalOptions
+    };
+  }
+  async function runResolvedBundleBuild(finalOptions) {
+    if (!finalOptions) {
+      return;
+    }
+    if (oxcVitePlugin) {
+      const toPluginArray = (plugins) => {
+        const queue = [];
+        const result = [];
+        if (plugins) {
+          queue.push(plugins);
+        }
+        while (queue.length > 0) {
+          const current2 = queue.shift();
+          if (!current2) {
+            continue;
           }
-          while (queue.length > 0) {
-            const current2 = queue.shift();
-            if (!current2) {
-              continue;
-            }
-            if (Array.isArray(current2)) {
-              queue.unshift(...current2);
-              continue;
-            }
-            result.push(current2);
+          if (Array.isArray(current2)) {
+            queue.unshift(...current2);
+            continue;
           }
-          return result;
-        };
-        const existing = toPluginArray(finalOptions.plugins);
-        const hasPlugin = existing.includes(oxcVitePlugin);
-        const nextPlugins = hasPlugin ? existing : [oxcVitePlugin, ...existing];
-        finalOptions.plugins = nextPlugins;
-      }
-      await viteBuild(finalOptions);
+          result.push(current2);
+        }
+        return result;
+      };
+      const existing = toPluginArray(finalOptions.plugins);
+      const hasPlugin = existing.includes(oxcVitePlugin);
+      const nextPlugins = hasPlugin ? existing : [oxcVitePlugin, ...existing];
+      finalOptions.plugins = nextPlugins;
     }
+    await viteBuild(finalOptions);
+  }
+  async function bundleBuild({ entry, name, options, outDir }) {
+    const resolvedTarget = resolvePackageBuildTarget({
+      entry,
+      name,
+      options,
+      outDir
+    });
+    await runResolvedBundleBuild(resolvedTarget.options);
   }
   async function copyBuild({ from, to }) {
     await fs37.copy(
@@ -36340,8 +36581,24 @@ function createPackageBuilder(ctx, oxcVitePlugin) {
     const { packageJson: targetJson, rootPath } = packageInfo;
     const dependencies = targetJson.dependencies ?? {};
     const keys = Object.keys(dependencies);
-    const destOutDir = path72.resolve(outDir, dep);
     if (isMiniprogramPackage(targetJson)) {
+      const sourceDir = path73.resolve(
+        rootPath,
+        targetJson.miniprogram
+      );
+      const resolvedTarget = resolvePackageBuildTarget({
+        entry: {
+          index: sourceDir
+        },
+        name: dep,
+        options,
+        outDir: path73.resolve(outDir, dep)
+      });
+      const destOutDir = resolvedTarget.outDir;
+      if (!resolvedTarget.options) {
+        npmLogger.info(`[npm] \u4F9D\u8D56 \`${dep}\` \u88AB npm.buildOptions \u8DF3\u8FC7\u5904\u7406!`);
+        return;
+      }
       if (await shouldSkipBuild(destOutDir, isDependenciesCacheOutdate)) {
         const alipayNpmDistDirName = getAlipayNpmDistDirName(ctx.configService.weappViteConfig?.npm?.alipayNpmMode);
         const shouldRebuildAlipayPackage = ctx.configService.platform === "alipay" ? await shouldRebuildCachedAlipayMiniprogramPackage(destOutDir, outDir, rootPath, alipayNpmDistDirName) : false;
@@ -36351,10 +36608,7 @@ function createPackageBuilder(ctx, oxcVitePlugin) {
         }
       }
       await copyBuild({
-        from: path72.resolve(
-          rootPath,
-          targetJson.miniprogram
-        ),
+        from: sourceDir,
         to: destOutDir,
         name: dep
       });
@@ -36384,8 +36638,21 @@ function createPackageBuilder(ctx, oxcVitePlugin) {
         npmLogger.warn(`[npm] \u65E0\u6CD5\u89E3\u6790\u6A21\u5757 \`${dep}\`\uFF0C\u8DF3\u8FC7\u5904\u7406!`);
         return;
       }
+      const resolvedTarget = resolvePackageBuildTarget({
+        entry: {
+          index
+        },
+        name: dep,
+        options,
+        outDir: path73.resolve(outDir, dep)
+      });
+      const destOutDir = resolvedTarget.outDir;
+      if (!resolvedTarget.options) {
+        npmLogger.info(`[npm] \u4F9D\u8D56 \`${dep}\` \u88AB npm.buildOptions \u8DF3\u8FC7\u5904\u7406!`);
+        return;
+      }
       if (!isDependenciesCacheOutdate && await fs37.pathExists(destOutDir)) {
-        const destEntry = path72.resolve(destOutDir, "index.js");
+        const destEntry = path73.resolve(destOutDir, "index.js");
         if (await fs37.pathExists(destEntry)) {
           const [srcStat, destStat] = await Promise.all([fs37.stat(index), fs37.stat(destEntry)]);
           if (srcStat.mtimeMs <= destStat.mtimeMs) {
@@ -36394,14 +36661,7 @@ function createPackageBuilder(ctx, oxcVitePlugin) {
           }
         }
       }
-      await bundleBuild({
-        entry: {
-          index
-        },
-        name: dep,
-        options,
-        outDir: destOutDir
-      });
+      await runResolvedBundleBuild(resolvedTarget.options);
       if (keys.length > 0) {
         await Promise.all(
           keys.filter((x3) => isBuiltin(x3)).map((x3) => {
@@ -36418,7 +36678,7 @@ function createPackageBuilder(ctx, oxcVitePlugin) {
     npmLogger.success(`[npm] \`${dep}\` \u4F9D\u8D56\u5904\u7406\u5B8C\u6210!`);
   }
   buildPackage = async ({ dep, outDir, options, isDependenciesCacheOutdate }) => {
-    const taskKey = `${path72.resolve(outDir)}::${dep}`;
+    const taskKey = `${path73.resolve(outDir)}::${dep}`;
     const pending = packageBuildInFlight.get(taskKey);
     if (pending) {
       return pending;
@@ -36449,21 +36709,49 @@ function createPackageBuilder(ctx, oxcVitePlugin) {
 init_esm_shims();
 import { isObject as isObject11, objectHash } from "@weapp-core/shared";
 import fs38 from "fs-extra";
-import path73 from "pathe";
+import path74 from "pathe";
+var CACHE_KEY_RE = /[\\/]/;
+function serializeDependencyScope(scope) {
+  if (scope === false) {
+    return false;
+  }
+  if (!Array.isArray(scope)) {
+    return void 0;
+  }
+  return scope.map((item) => {
+    return typeof item === "string" ? item : item.toString();
+  });
+}
+function resolveMainPackageDependencyScope(ctx) {
+  const configService = requireConfigService(ctx, "\u8BFB\u53D6\u4E3B\u5305 npm \u4F9D\u8D56\u8303\u56F4\u524D\u5FC5\u987B\u521D\u59CB\u5316 configService\u3002");
+  return configService.weappViteConfig?.npm?.mainPackage?.dependencies;
+}
 function createDependenciesCache(ctx) {
   function getDependenciesCacheFilePath(key = "/") {
     const configService = requireConfigService(ctx, "\u751F\u6210 npm \u7F13\u5B58\u8DEF\u5F84\u524D\u5FC5\u987B\u521D\u59CB\u5316 configService\u3002");
-    return path73.resolve(configService.cwd, `node_modules/weapp-vite/.cache/${key.replace(/[\\/]/g, "-")}.json`);
+    return path74.resolve(configService.cwd, `node_modules/weapp-vite/.cache/${key.replace(CACHE_KEY_RE, "-")}.json`);
   }
-  function dependenciesCacheHash() {
+  function resolveDependencyScope(root) {
+    if (root === "__all__") {
+      return void 0;
+    }
+    if (root && root !== "/") {
+      return ctx.scanService?.subPackageMap.get(root)?.subPackage.dependencies;
+    }
+    return resolveMainPackageDependencyScope(ctx);
+  }
+  function dependenciesCacheHash(root) {
     const configService = requireConfigService(ctx, "\u8BFB\u53D6\u4F9D\u8D56\u7F13\u5B58\u54C8\u5E0C\u524D\u5FC5\u987B\u521D\u59CB\u5316 configService\u3002");
-    return objectHash(configService.packageJson.dependencies ?? {});
+    return objectHash({
+      dependencies: configService.packageJson.dependencies ?? {},
+      scope: serializeDependencyScope(resolveDependencyScope(root))
+    });
   }
   async function writeDependenciesCache(root) {
     const configService = requireConfigService(ctx, "\u5199\u5165 npm \u7F13\u5B58\u524D\u5FC5\u987B\u521D\u59CB\u5316 configService\u3002");
     if (configService.weappViteConfig?.npm?.cache) {
       await fs38.outputJSON(getDependenciesCacheFilePath(root), {
-        hash: dependenciesCacheHash()
+        hash: dependenciesCacheHash(root)
       });
     }
   }
@@ -36477,7 +36765,7 @@ function createDependenciesCache(ctx) {
     if (ctx.configService?.weappViteConfig?.npm?.cache) {
       const json = await readDependenciesCache(root);
       if (isObject11(json)) {
-        return dependenciesCacheHash() !== json.hash;
+        return dependenciesCacheHash(root) !== json.hash;
       }
       return true;
     }
@@ -36485,7 +36773,7 @@ function createDependenciesCache(ctx) {
   }
   return {
     getDependenciesCacheFilePath,
-    dependenciesCacheHash,
+    dependenciesCacheHash: () => dependenciesCacheHash(),
     writeDependenciesCache,
     readDependenciesCache,
     checkDependenciesCacheOutdate
@@ -36494,7 +36782,7 @@ function createDependenciesCache(ctx) {
 
 // src/runtime/npmPlugin/relations.ts
 init_esm_shims();
-import path74 from "pathe";
+import path75 from "pathe";
 function normalizeRelativeDir(value) {
   const normalized = toPosixPath(value).replace(/\/+$/, "");
   const trimmed = normalized.startsWith("./") ? normalized.slice(2) : normalized;
@@ -36543,13 +36831,13 @@ function getPackNpmRelationList(ctx) {
     return [
       {
         ...packNpmRelationList[0],
-        miniprogramNpmDistDir: path74.join("dist", configService.platform, resolvePlatformProjectRoot(configService))
+        miniprogramNpmDistDir: path75.join("dist", configService.platform, resolvePlatformProjectRoot(configService))
       }
     ];
   }
   return packNpmRelationList.map((entry) => {
     const rawDir = entry.miniprogramNpmDistDir;
-    if (!rawDir || path74.isAbsolute(rawDir)) {
+    if (!rawDir || path75.isAbsolute(rawDir)) {
       return entry;
     }
     const trimmed = normalizeRelativeDir(rawDir);
@@ -36560,12 +36848,83 @@ function getPackNpmRelationList(ctx) {
     }
     return {
       ...entry,
-      miniprogramNpmDistDir: path74.join("dist", configService.platform, trimmed)
+      miniprogramNpmDistDir: path75.join("dist", configService.platform, trimmed)
     };
   });
 }
 
 // src/runtime/npmPlugin/service.ts
+var LEADING_SLASHES_RE = /^\/+/;
+function matchDependencyName(patterns, dep) {
+  return patterns.some((pattern) => {
+    if (typeof pattern === "string") {
+      return pattern === dep;
+    }
+    pattern.lastIndex = 0;
+    return pattern.test(dep);
+  });
+}
+function resolveDependencyId2(value) {
+  const normalized = toPosixPath(value).replace(LEADING_SLASHES_RE, "");
+  const segments = normalized.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return "";
+  }
+  if (normalized.startsWith("@") && segments.length > 1) {
+    return `${segments[0]}/${segments[1]}`;
+  }
+  return segments[0];
+}
+function matchDependencyPath(patterns, value) {
+  const dependencyId = resolveDependencyId2(value);
+  return patterns.some((pattern) => {
+    if (typeof pattern === "string") {
+      return dependencyId === pattern || value === pattern || value.startsWith(`${pattern}/`);
+    }
+    pattern.lastIndex = 0;
+    if (pattern.test(dependencyId)) {
+      return true;
+    }
+    pattern.lastIndex = 0;
+    return pattern.test(value);
+  });
+}
+function resolveTargetDependencies(allDependencies, patterns) {
+  if (patterns === false) {
+    return [];
+  }
+  if (!Array.isArray(patterns)) {
+    return allDependencies;
+  }
+  const selected = /* @__PURE__ */ new Set();
+  for (const dep of allDependencies) {
+    if (matchDependencyName(patterns, dep)) {
+      selected.add(dep);
+    }
+  }
+  for (const pattern of patterns) {
+    if (typeof pattern === "string") {
+      selected.add(pattern);
+    }
+  }
+  return [...selected];
+}
+function hasSameDependencySet(source, target) {
+  if (source.length !== target.length) {
+    return false;
+  }
+  return source.every((dep) => target.includes(dep));
+}
+function resolveMainPackageDependencyPatterns(ctx) {
+  return ctx.configService?.weappViteConfig?.npm?.mainPackage?.dependencies;
+}
+function hasLocalSubPackageNpmConfig(ctx) {
+  const npmSubPackages = ctx.configService?.weappViteConfig?.npm?.subPackages;
+  if (npmSubPackages && Object.values(npmSubPackages).some((config) => Array.isArray(config?.dependencies) && config.dependencies.length > 0)) {
+    return true;
+  }
+  return false;
+}
 function createNpmService(ctx) {
   const oxcRuntimeSupport = createOxcRuntimeSupport();
   const oxcVitePlugin = oxcRuntimeSupport.vitePlugin;
@@ -36582,84 +36941,95 @@ function createNpmService(ctx) {
       return;
     }
     debug?.("buildNpm start");
+    if (ctx.scanService && hasLocalSubPackageNpmConfig(ctx) && typeof ctx.scanService.loadAppEntry === "function") {
+      await ctx.scanService.loadAppEntry();
+      if (typeof ctx.scanService.loadSubPackages === "function") {
+        ctx.scanService.loadSubPackages();
+      }
+    }
     const packNpmRelationList = getPackNpmRelationList(ctx);
     const [mainRelation, ...subRelations] = packNpmRelationList;
-    const packageJsonPath = path75.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
+    const packageJsonPath = path76.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
     if (await fs39.pathExists(packageJsonPath)) {
       const pkgJson = await fs39.readJson(packageJsonPath);
       const npmDistDirName = getNpmDistDirName();
-      const outDir = path75.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, npmDistDirName);
+      const outDir = path76.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, npmDistDirName);
+      const cachedSourceOutDir = path76.resolve(ctx.configService.cwd, "node_modules/weapp-vite/.cache/npm-source", npmDistDirName);
+      const localSubPackageOutRoot = ctx.configService.outDir || path76.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir);
       if (pkgJson.dependencies) {
-        const dependencies = Object.keys(pkgJson.dependencies);
-        if (dependencies.length > 0) {
-          const isDependenciesCacheOutdate = await cache2.checkDependenciesCacheOutdate();
+        const allDependencies = Object.keys(pkgJson.dependencies);
+        const mainDependencyPatterns = resolveMainPackageDependencyPatterns(ctx);
+        const mainDependencies = resolveTargetDependencies(allDependencies, mainDependencyPatterns);
+        const sourceOutDir = hasSameDependencySet(allDependencies, mainDependencies) ? outDir : cachedSourceOutDir;
+        const localSubPackageMetas = [...ctx.scanService?.subPackageMap.values() ?? []].filter((meta) => Array.isArray(meta.subPackage.dependencies) && meta.subPackage.dependencies.length > 0);
+        const buildTargetDependencies = async (args) => {
+          const isNpmDistMissing = !await fs39.pathExists(args.npmDistDir);
+          const isDependenciesCacheOutdate = isNpmDistMissing || await cache2.checkDependenciesCacheOutdate(args.cacheKey);
+          if (isDependenciesCacheOutdate) {
+            await fs39.remove(args.npmDistDir);
+          }
+          if (args.dependencies.length === 0) {
+            await fs39.remove(args.npmDistDir);
+            await cache2.writeDependenciesCache(args.cacheKey);
+            return;
+          }
           await Promise.all(
-            dependencies.map((dep) => {
+            args.dependencies.map((dep) => {
               return builder.buildPackage({
                 dep,
-                outDir,
+                outDir: args.npmDistDir,
                 options,
                 isDependenciesCacheOutdate
               });
             })
           );
-          await cache2.writeDependenciesCache();
-          const targetDirs = [
-            ...subRelations.map((x3) => {
-              return {
-                npmDistDir: path75.resolve(ctx.configService.cwd, x3.miniprogramNpmDistDir, npmDistDirName)
-              };
-            }),
-            ...[...ctx.scanService.independentSubPackageMap.values()].map((x3) => {
-              const dependencies2 = x3.subPackage.dependencies;
-              return {
-                root: x3.subPackage.root,
-                dependencies: dependencies2,
-                npmDistDir: path75.resolve(ctx.configService.cwd, mainRelation.miniprogramNpmDistDir, x3.subPackage.root, npmDistDirName)
-              };
-            })
-          ];
-          const uniqueTargetDirs = Array.from(
-            new Map(
-              targetDirs.map((item) => [item.npmDistDir, item])
-            ).values()
-          );
-          await Promise.all(uniqueTargetDirs.map(async (x3) => {
-            if (x3.root) {
-              const isDependenciesCacheOutdate2 = await cache2.checkDependenciesCacheOutdate(x3.root);
-              if (isDependenciesCacheOutdate2 || !await fs39.pathExists(x3.npmDistDir)) {
-                await fs39.copy(outDir, x3.npmDistDir, {
-                  overwrite: true,
-                  filter: (src) => {
-                    if (Array.isArray(x3.dependencies)) {
-                      const relPath = toPosixPath(path75.relative(outDir, src));
-                      if (relPath === "") {
-                        return true;
-                      }
-                      return regExpTest(x3.dependencies, relPath);
-                    }
+          await cache2.writeDependenciesCache(args.cacheKey);
+        };
+        if (sourceOutDir !== outDir) {
+          await buildTargetDependencies({
+            cacheKey: "__all__",
+            dependencies: allDependencies,
+            npmDistDir: sourceOutDir
+          });
+        }
+        await buildTargetDependencies({
+          dependencies: mainDependencies,
+          npmDistDir: outDir
+        });
+        if (mainDependencies.length === 0) {
+          await Promise.all(subRelations.map((relation) => {
+            return fs39.remove(path76.resolve(ctx.configService.cwd, relation.miniprogramNpmDistDir, npmDistDirName));
+          }));
+        } else {
+          await Promise.all(subRelations.map(async (relation) => {
+            const targetDir = path76.resolve(ctx.configService.cwd, relation.miniprogramNpmDistDir, npmDistDirName);
+            await fs39.remove(targetDir);
+            await fs39.copy(outDir, targetDir, {
+              overwrite: true
+            });
+          }));
+        }
+        await Promise.all(Array.from(localSubPackageMetas, async (meta) => {
+          const targetDir = path76.resolve(localSubPackageOutRoot, meta.subPackage.root, npmDistDirName);
+          const isDependenciesCacheOutdate = await cache2.checkDependenciesCacheOutdate(meta.subPackage.root);
+          if (isDependenciesCacheOutdate || !await fs39.pathExists(targetDir)) {
+            await fs39.remove(targetDir);
+            await fs39.copy(sourceOutDir, targetDir, {
+              overwrite: true,
+              filter: (src) => {
+                if (Array.isArray(meta.subPackage.dependencies)) {
+                  const relPath = toPosixPath(path76.relative(sourceOutDir, src));
+                  if (relPath === "") {
                     return true;
                   }
-                });
-              }
-              await cache2.writeDependenciesCache(x3.root);
-            } else {
-              await fs39.copy(outDir, x3.npmDistDir, {
-                overwrite: true,
-                filter: (src) => {
-                  if (Array.isArray(x3.dependencies)) {
-                    const relPath = toPosixPath(path75.relative(outDir, src));
-                    if (relPath === "") {
-                      return true;
-                    }
-                    return regExpTest(x3.dependencies, relPath);
-                  }
-                  return true;
+                  return matchDependencyPath(meta.subPackage.dependencies, relPath);
                 }
-              });
-            }
-          }));
-        }
+                return true;
+              }
+            });
+          }
+          await cache2.writeDependenciesCache(meta.subPackage.root);
+        }));
       }
     }
     debug?.("buildNpm end");
@@ -37770,12 +38140,12 @@ init_esm_shims();
 // src/runtime/scanPlugin/service.ts
 init_esm_shims();
 import { isObject as isObject12 } from "@weapp-core/shared";
-import path79 from "pathe";
+import path80 from "pathe";
 
 // src/runtime/scanPlugin/styleEntries/index.ts
 init_esm_shims();
 import fs42 from "fs-extra";
-import path78 from "pathe";
+import path79 from "pathe";
 
 // src/runtime/scanPlugin/styleEntries/config.ts
 init_esm_shims();
@@ -37846,7 +38216,7 @@ function coerceStyleConfig(entry) {
 // src/runtime/scanPlugin/styleEntries/entries.ts
 init_esm_shims();
 import fs41 from "fs-extra";
-import path76 from "pathe";
+import path77 from "pathe";
 
 // src/runtime/scanPlugin/styleEntries/patterns.ts
 init_esm_shims();
@@ -37930,18 +38300,18 @@ function addStyleEntry(descriptor, absolutePath, posixOutput, root, normalizedRo
     source: descriptor.source,
     absolutePath,
     outputRelativePath: posixOutput,
-    inputExtension: path76.extname(absolutePath).toLowerCase(),
+    inputExtension: path77.extname(absolutePath).toLowerCase(),
     scope: descriptor.scope,
     include,
     exclude
   });
 }
 function appendDefaultScopedStyleEntries(root, normalizedRoot, service, dedupe, normalized) {
-  const absoluteSubRoot = path76.resolve(service.absoluteSrcRoot, root);
+  const absoluteSubRoot = path77.resolve(service.absoluteSrcRoot, root);
   for (const { base, scope } of DEFAULT_SCOPED_FILES) {
     for (const ext of DEFAULT_SCOPED_EXTENSIONS) {
       const filename = `${base}${ext}`;
-      const absolutePath = path76.resolve(absoluteSubRoot, filename);
+      const absolutePath = path77.resolve(absoluteSubRoot, filename);
       if (!fs41.existsSync(absolutePath)) {
         continue;
       }
@@ -37966,7 +38336,7 @@ function appendDefaultScopedStyleEntries(root, normalizedRoot, service, dedupe,
 
 // src/runtime/scanPlugin/styleEntries/resolve.ts
 init_esm_shims();
-import path77 from "pathe";
+import path78 from "pathe";
 function resolveStyleEntryAbsolutePath(source, subPackageRoot, configService) {
   const service = configService;
   if (!service) {
@@ -37977,17 +38347,17 @@ function resolveStyleEntryAbsolutePath(source, subPackageRoot, configService) {
     return void 0;
   }
   const srcRoot = service.absoluteSrcRoot;
-  const absoluteSubRoot = path77.resolve(srcRoot, subPackageRoot);
+  const absoluteSubRoot = path78.resolve(srcRoot, subPackageRoot);
   const normalizedEntry = toPosixPath(trimmed);
   const normalizedRoot = toPosixPath(subPackageRoot);
   const candidates = [];
-  if (path77.isAbsolute(trimmed)) {
+  if (path78.isAbsolute(trimmed)) {
     candidates.push(trimmed);
   } else if (normalizedEntry === normalizedRoot || normalizedEntry.startsWith(`${normalizedRoot}/`)) {
-    candidates.push(path77.resolve(srcRoot, trimmed));
+    candidates.push(path78.resolve(srcRoot, trimmed));
   } else {
-    candidates.push(path77.resolve(absoluteSubRoot, trimmed));
-    candidates.push(path77.resolve(srcRoot, trimmed));
+    candidates.push(path78.resolve(absoluteSubRoot, trimmed));
+    candidates.push(path78.resolve(srcRoot, trimmed));
   }
   for (const candidate of candidates) {
     if (isPathInside(srcRoot, candidate)) {
@@ -38015,7 +38385,7 @@ function inferScopeFromRelativePath(relativePath) {
   if (cleaned.includes("/")) {
     return void 0;
   }
-  const base = path77.posix.basename(cleaned, path77.posix.extname(cleaned));
+  const base = path78.posix.basename(cleaned, path78.posix.extname(cleaned));
   if (base === "pages") {
     return "pages";
   }
@@ -38057,7 +38427,7 @@ function normalizeSubPackageStyleEntries(styles, subPackage, configService) {
       default2.warn(`[\u5206\u5305] \u5206\u5305 ${root} \u6837\u5F0F\u5165\u53E3 \`${descriptor.source}\` \u5BF9\u5E94\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u5DF2\u5FFD\u7565\u3002`);
       continue;
     }
-    const ext = path78.extname(absolutePath).toLowerCase();
+    const ext = path79.extname(absolutePath).toLowerCase();
     if (!SUPPORTED_SHARED_STYLE_EXTS.has(ext)) {
       default2.warn(`[\u5206\u5305] \u5206\u5305 ${root} \u6837\u5F0F\u5165\u53E3 \`${descriptor.source}\` \u5F53\u524D\u4EC5\u652F\u6301\u4EE5\u4E0B\u683C\u5F0F\uFF1A${SUPPORTED_SHARED_STYLE_EXTENSIONS.join(", ")}\uFF0C\u5DF2\u5FFD\u7565\u3002`);
       continue;
@@ -38109,7 +38479,7 @@ function createScanService(ctx) {
       return scanState.appEntry;
     }
     const appDirname = ctx.configService.absoluteSrcRoot;
-    const appBasename = path79.resolve(appDirname, "app");
+    const appBasename = path80.resolve(appDirname, "app");
     let { path: appConfigFile } = await findJsonEntry(appBasename);
     const { path: appEntryPath } = await findJsEntry(appBasename);
     let configFromVue;
@@ -38118,14 +38488,14 @@ function createScanService(ctx) {
       vueAppPath = await findVueEntry(appBasename);
     }
     if (!appConfigFile && vueAppPath) {
-      const { extractConfigFromVue: extractConfigFromVue2 } = await import("./file-IRTTGBIN.mjs");
+      const { extractConfigFromVue: extractConfigFromVue2 } = await import("./file-VKNW65BI.mjs");
       configFromVue = await extractConfigFromVue2(vueAppPath);
       if (configFromVue) {
         appConfigFile = vueAppPath;
       }
     }
     if (ctx.configService.absolutePluginRoot) {
-      const pluginBasename = path79.resolve(ctx.configService.absolutePluginRoot, "plugin");
+      const pluginBasename = path80.resolve(ctx.configService.absolutePluginRoot, "plugin");
       const { path: pluginConfigFile } = await findJsonEntry(pluginBasename);
       if (pluginConfigFile) {
         const pluginConfig = await ctx.jsonService.read(pluginConfigFile);
@@ -38154,14 +38524,14 @@ function createScanService(ctx) {
         scanState.appEntry = resolvedAppEntry;
         const { sitemapLocation = "sitemap.json", themeLocation = "theme.json" } = config;
         if (sitemapLocation) {
-          const { path: sitemapJsonPath } = await findJsonEntry(path79.resolve(appDirname, sitemapLocation));
+          const { path: sitemapJsonPath } = await findJsonEntry(path80.resolve(appDirname, sitemapLocation));
           if (sitemapJsonPath) {
             resolvedAppEntry.sitemapJsonPath = sitemapJsonPath;
             resolvedAppEntry.sitemapJson = await ctx.jsonService.read(sitemapJsonPath);
           }
         }
         if (themeLocation) {
-          const { path: themeJsonPath } = await findJsonEntry(path79.resolve(appDirname, themeLocation));
+          const { path: themeJsonPath } = await findJsonEntry(path80.resolve(appDirname, themeLocation));
           if (themeJsonPath) {
             resolvedAppEntry.themeJsonPath = themeJsonPath;
             resolvedAppEntry.themeJson = await ctx.jsonService.read(themeJsonPath);
@@ -38195,7 +38565,8 @@ function createScanService(ctx) {
             entries: resolveSubPackageEntries(subPackage)
           };
           const subPackageConfig = configService.weappViteConfig?.subPackages?.[subPackage.root];
-          meta.subPackage.dependencies = subPackageConfig?.dependencies;
+          const npmSubPackageConfig = configService.weappViteConfig?.npm?.subPackages?.[subPackage.root];
+          meta.subPackage.dependencies = npmSubPackageConfig?.dependencies;
           meta.subPackage.inlineConfig = subPackageConfig?.inlineConfig;
           meta.autoImportComponents = subPackageConfig?.autoImportComponents;
           meta.styleEntries = normalizeSubPackageStyleEntries(
@@ -38223,12 +38594,12 @@ function createScanService(ctx) {
       }
     }
     if (scanState.appEntry) {
-      return Array.from(subPackageMap.values());
+      return [...subPackageMap.values()];
     }
     throw new Error(`\u5728 ${configService.absoluteSrcRoot} \u76EE\u5F55\u4E0B\u6CA1\u6709\u627E\u5230 \`app.json\`, \u8BF7\u786E\u4FDD\u4F60\u521D\u59CB\u5316\u4E86\u5C0F\u7A0B\u5E8F\u9879\u76EE\uFF0C\u6216\u8005\u5728 \`vite.config.ts\` \u4E2D\u8BBE\u7F6E\u7684\u6B63\u786E\u7684 \`weapp.srcRoot\` \u914D\u7F6E\u8DEF\u5F84  `);
   }
   function isMainPackageFileName(fileName) {
-    return Array.from(independentSubPackageMap.keys()).every((root) => {
+    return [...independentSubPackageMap.keys()].every((root) => {
       return !fileName.startsWith(root);
     });
   }
@@ -38280,7 +38651,7 @@ function createScanService(ctx) {
       }
     },
     drainIndependentDirtyRoots() {
-      const roots = Array.from(independentDirtyRoots);
+      const roots = [...independentDirtyRoots];
       independentDirtyRoots.clear();
       return roots;
     }
@@ -38439,7 +38810,7 @@ function createWebServicePlugin(ctx) {
 init_esm_shims();
 import { removeExtensionDeep as removeExtensionDeep15 } from "@weapp-core/shared";
 import fs43 from "fs-extra";
-import path80 from "pathe";
+import path81 from "pathe";
 function createWxmlService(ctx) {
   const { depsMap, tokenMap, componentsMap, cache: cache2, emittedCode } = ctx.runtimeState.wxml;
   async function addDeps(filepath, deps = []) {
@@ -38555,7 +38926,7 @@ function createWxmlService(ctx) {
         return cached;
       }
     }
-    const dirname5 = path80.dirname(filepath);
+    const dirname5 = path81.dirname(filepath);
     const wxml = await fs43.readFile(filepath, "utf8");
     const res = analyze(wxml);
     tokenMap.set(filepath, res);
@@ -38564,9 +38935,9 @@ function createWxmlService(ctx) {
       filepath,
       res.deps.filter((x3) => isImportTag(x3.tagName) && isTemplate(x3.value)).map((x3) => {
         if (x3.value.startsWith("/")) {
-          return path80.resolve(configService.absoluteSrcRoot, x3.value.slice(1));
+          return path81.resolve(configService.absoluteSrcRoot, x3.value.slice(1));
         } else {
-          return path80.resolve(dirname5, x3.value);
+          return path81.resolve(dirname5, x3.value);
         }
       })
     );