weapp-vite 5.6.1 → 5.6.2

package/dist/{chunk-6JB3ELRA.cjs → chunk-XMRIIXBJ.cjs}

@@ -4484,11 +4484,12 @@ function createAutoRoutesServicePlugin(ctx) {
 
 // src/runtime/buildPlugin.ts
 _chunkWWFEREWVcjs.init_cjs_shims.call(void 0, );
+var _fs = require('fs'); var actualFS = _interopRequireWildcard(_fs);
 
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 _chunkWWFEREWVcjs.init_cjs_shims.call(void 0, );
-var _fs = require('fs'); var actualFS = _interopRequireWildcard(_fs);
+
 var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
 var _events2 = require('events');
 var _path = require('path'); var sysPath2 = _interopRequireWildcard(_path); var sysPath = _interopRequireWildcard(_path);
@@ -9537,8 +9538,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs25 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs25);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs26 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs26);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = _url.fileURLToPath.call(void 0, cwd);
     }
@@ -10096,8 +10097,8 @@ var PathScurryWin32 = (_class9 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs25) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs25 });
+  newRoot(fs26) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs26 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -10125,8 +10126,8 @@ var PathScurryPosix = (_class10 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs25) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs25 });
+  newRoot(fs26) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs26 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -12538,11 +12539,45 @@ function createBuildService(ctx) {
             ignoreInitial: true
           }
         );
+        const logWorkerEvent = (type, target, level = "info") => {
+          if (!target) {
+            return;
+          }
+          const relative3 = configService.relativeCwd(target);
+          const message = `[workers:${type}] ${relative3}`;
+          if (level === "success") {
+            logger_default.success(message);
+          } else {
+            logger_default.info(message);
+          }
+        };
         watcher2.on("all", (event, id) => {
+          if (!id) {
+            return;
+          }
           if (event === "add") {
-            logger_default.success(`[workers:${event}] ${configService.relativeCwd(id)}`);
+            logWorkerEvent(event, id, "success");
             void devWorkers(workersDir);
+            return;
+          }
+          logWorkerEvent(event, id);
+        });
+        watcher2.on("raw", (eventName, rawPath, details) => {
+          if (eventName !== "rename") {
+            return;
+          }
+          const candidate = typeof rawPath === "string" ? rawPath : rawPath && typeof rawPath.toString === "function" ? rawPath.toString() : "";
+          if (!candidate) {
+            return;
+          }
+          const baseDir = typeof details === "object" && details && "watchedPath" in details ? _nullishCoalesce(details.watchedPath, () => ( absWorkerRoot)) : absWorkerRoot;
+          const resolved = _pathe2.default.isAbsolute(candidate) ? candidate : _pathe2.default.resolve(baseDir, candidate);
+          const exists = actualFS.default.existsSync(resolved);
+          if (exists) {
+            logWorkerEvent("rename->add", resolved);
+            return;
           }
+          logWorkerEvent("rename->unlink", resolved);
         });
         watcherService.sidecarWatcherMap.set(absWorkerRoot, {
           close: () => watcher2.close()
@@ -20208,7 +20243,7 @@ function createOxcRuntimeSupport() {
       if (helperName) {
         const helperPath = id.startsWith(NULL_BYTE) ? _pathe2.default.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`) : id;
         if (await _fsextra2.default.pathExists(helperPath)) {
-          console.warn("[weapp-vite] resolving oxc helper via Rolldown plugin:", helperName);
+          logger_default.warn(`[weapp-vite] resolving oxc helper via Rolldown plugin: ${helperName}`);
           return _fsextra2.default.readFile(helperPath, "utf8");
         }
         const fallback = fallbackHelpers[helperName];
@@ -20227,7 +20262,7 @@ function createOxcRuntimeSupport() {
         return null;
       }
       if (source.includes("@oxc-project/runtime/helpers")) {
-        console.warn("[weapp-vite] resolveId intercepted:", source);
+        logger_default.warn(`[weapp-vite] resolveId intercepted: ${source}`);
       }
       const helperName = getOxcHelperName(source);
       if (helperName) {
@@ -20244,7 +20279,7 @@ function createOxcRuntimeSupport() {
         return null;
       }
       const helperPath = _pathe2.default.resolve(oxcRuntimeHelpersRoot, `${helperName}.js`);
-      console.warn("[weapp-vite] resolving oxc helper via Vite plugin:", helperName);
+      logger_default.warn(`[weapp-vite] resolving oxc helper via Vite plugin: ${helperName}`);
       return _fsextra2.default.readFile(helperPath, "utf8");
     }
   };
@@ -20837,46 +20872,14 @@ _chunkWWFEREWVcjs.init_cjs_shims.call(void 0, );
 
 
 
-function asset(ctx) {
-  const state = { ctx };
-  return [createAssetCollector(state)];
-}
-function createAssetCollector(state) {
-  const { ctx } = state;
-  const { configService } = ctx;
-  return {
-    name: "weapp-vite:asset",
-    enforce: "pre",
-    configResolved(config) {
-      state.resolvedConfig = config;
-    },
-    buildStart() {
-      if (!state.resolvedConfig) {
-        state.pendingAssets = Promise.resolve([]);
-        return;
-      }
-      state.pendingAssets = scanAssetFiles(configService, state.resolvedConfig);
-    },
-    async buildEnd() {
-      const assets = await state.pendingAssets;
-      if (!_optionalChain([assets, 'optionalAccess', _324 => _324.length])) {
-        return;
-      }
-      for (const candidate of assets) {
-        this.emitFile({
-          type: "asset",
-          fileName: configService.relativeAbsoluteSrcRoot(candidate.file),
-          source: candidate.buffer
-        });
-      }
-    }
-  };
+function normalizeCopyGlobs(globs) {
+  return Array.isArray(globs) ? globs : [];
 }
 function scanAssetFiles(configService, config) {
   const weappViteConfig = configService.weappViteConfig;
-  const include = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _325 => _325.copy, 'optionalAccess', _326 => _326.include]));
-  const exclude = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _327 => _327.copy, 'optionalAccess', _328 => _328.exclude]));
-  const filter3 = _nullishCoalesce(_optionalChain([weappViteConfig, 'optionalAccess', _329 => _329.copy, 'optionalAccess', _330 => _330.filter]), () => ( (() => true)));
+  const include = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _324 => _324.copy, 'optionalAccess', _325 => _325.include]));
+  const exclude = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _326 => _326.copy, 'optionalAccess', _327 => _327.exclude]));
+  const filter3 = _nullishCoalesce(_optionalChain([weappViteConfig, 'optionalAccess', _328 => _328.copy, 'optionalAccess', _329 => _329.filter]), () => ( (() => true)));
   const ignore = [
     ...defaultExcluded,
     _pathe2.default.resolve(configService.cwd, `${config.build.outDir}/**/*`),
@@ -20916,8 +20919,40 @@ function scanAssetFiles(configService, config) {
     );
   });
 }
-function normalizeCopyGlobs(globs) {
-  return Array.isArray(globs) ? globs : [];
+function createAssetCollector(state) {
+  const { ctx } = state;
+  const { configService } = ctx;
+  return {
+    name: "weapp-vite:asset",
+    enforce: "pre",
+    configResolved(config) {
+      state.resolvedConfig = config;
+    },
+    buildStart() {
+      if (!state.resolvedConfig) {
+        state.pendingAssets = Promise.resolve([]);
+        return;
+      }
+      state.pendingAssets = scanAssetFiles(configService, state.resolvedConfig);
+    },
+    async buildEnd() {
+      const assets = await state.pendingAssets;
+      if (!_optionalChain([assets, 'optionalAccess', _330 => _330.length])) {
+        return;
+      }
+      for (const candidate of assets) {
+        this.emitFile({
+          type: "asset",
+          fileName: configService.relativeAbsoluteSrcRoot(candidate.file),
+          source: candidate.buffer
+        });
+      }
+    }
+  };
+}
+function asset(ctx) {
+  const state = { ctx };
+  return [createAssetCollector(state)];
 }
 
 // src/plugins/autoImport.ts
@@ -22843,22 +22878,6 @@ function createEntryLoader(options) {
 _chunkWWFEREWVcjs.init_cjs_shims.call(void 0, );
 
 
-function createEntryNormalizer(configService) {
-  return function normalizeEntry(entry, jsonPath) {
-    if (/plugin:\/\//.test(entry)) {
-      return entry;
-    }
-    const tokens = entry.split("/");
-    if (tokens[0] && _shared.isObject.call(void 0, configService.packageJson.dependencies) && hasDependencyPrefix(configService.packageJson.dependencies, tokens)) {
-      return `npm:${entry}`;
-    }
-    if (tokens[0] === "") {
-      return entry.substring(1);
-    }
-    const normalized = resolveImportee2(entry, jsonPath, configService);
-    return configService.relativeAbsoluteSrcRoot(normalized);
-  };
-}
 function resolveImportee2(importee, jsonPath, configService) {
   let updated = importee;
   if (jsonPath && Array.isArray(configService.aliasEntries)) {
@@ -22881,6 +22900,22 @@ function hasDependencyPrefix(dependencies, tokens) {
     return true;
   });
 }
+function createEntryNormalizer(configService) {
+  return function normalizeEntry(entry, jsonPath) {
+    if (/plugin:\/\//.test(entry)) {
+      return entry;
+    }
+    const tokens = entry.split("/");
+    if (tokens[0] && _shared.isObject.call(void 0, configService.packageJson.dependencies) && hasDependencyPrefix(configService.packageJson.dependencies, tokens)) {
+      return `npm:${entry}`;
+    }
+    if (tokens[0] === "") {
+      return entry.substring(1);
+    }
+    const normalized = resolveImportee2(entry, jsonPath, configService);
+    return configService.relativeAbsoluteSrcRoot(normalized);
+  };
+}
 
 // src/plugins/hooks/useLoadEntry/template.ts
 _chunkWWFEREWVcjs.init_cjs_shims.call(void 0, );
@@ -22961,11 +22996,15 @@ _chunkWWFEREWVcjs.init_cjs_shims.call(void 0, );
 
 
 var watchedCssExts = new Set(supportedCssLangs.map((ext2) => `.${ext2}`));
+var watchedTemplateExts = new Set(templateExtensions.map((ext2) => `.${ext2}`));
 var configSuffixes = configExtensions.map((ext2) => `.${ext2}`);
-var sidecarSuffixes = [...configSuffixes, ...watchedCssExts];
+var sidecarSuffixes = [...configSuffixes, ...watchedCssExts, ...watchedTemplateExts];
 var watchLimitErrorCodes = /* @__PURE__ */ new Set(["EMFILE", "ENOSPC"]);
 var importProtocols = /^(?:https?:|data:|blob:|\/)/i;
-var cssImportRE = /@(import|wv-keep-import)\s+(?:url\()?['"]?([^'")\s]+)['"]?\)?/gi;
+var cssImportRE = /@(?:import|wv-keep-import)\s+(?:url\()?['"]?([^'")\s]+)['"]?\)?/gi;
+function isSidecarFile(filePath) {
+  return sidecarSuffixes.some((suffix) => filePath.endsWith(suffix));
+}
 function isWatchLimitError(error) {
   if (!error || typeof error !== "object") {
     return false;
@@ -23063,7 +23102,7 @@ async function extractCssImportDependencies(ctx, importer) {
     if (!match2) {
       break;
     }
-    const rawSpecifier = _optionalChain([match2, 'access', _362 => _362[2], 'optionalAccess', _363 => _363.trim, 'call', _364 => _364()]);
+    const rawSpecifier = _optionalChain([match2, 'access', _362 => _362[1], 'optionalAccess', _363 => _363.trim, 'call', _364 => _364()]);
     if (!rawSpecifier) {
       continue;
     }
@@ -23173,6 +23212,8 @@ async function invalidateEntryForSidecar(ctx, filePath, event = "update") {
     scriptBasePath = filePath.slice(0, -configSuffix.length);
   } else if (ext2 && watchedCssExts.has(ext2)) {
     scriptBasePath = filePath.slice(0, -ext2.length);
+  } else if (ext2 && watchedTemplateExts.has(ext2)) {
+    scriptBasePath = filePath.slice(0, -ext2.length);
   }
   if (!scriptBasePath) {
     return;
@@ -23193,6 +23234,7 @@ async function invalidateEntryForSidecar(ctx, filePath, event = "update") {
     }
   }
   const isCssSidecar = Boolean(ext2 && watchedCssExts.has(ext2));
+  const isTemplateSidecar = Boolean(ext2 && watchedTemplateExts.has(ext2));
   const configService = ctx.configService;
   const relativeSource = configService.relativeCwd(normalizedPath);
   for (const target of touchedTargets) {
@@ -23208,7 +23250,7 @@ async function invalidateEntryForSidecar(ctx, filePath, event = "update") {
     }
   }
   if (!touchedTargets.size && !touchedScripts.size) {
-    if (event === "create" && isCssSidecar) {
+    if (event === "create" && (isCssSidecar || isTemplateSidecar)) {
       logger_default.info(`[sidecar:${event}] ${relativeSource} \u65B0\u589E\uFF0C\u4F46\u672A\u627E\u5230\u5F15\u7528\u65B9\uFF0C\u7B49\u5F85\u540E\u7EED\u5173\u8054`);
     }
     return;
@@ -23245,23 +23287,25 @@ function ensureSidecarWatcher(ctx, rootDir) {
     if (isCssFile && (event === "create" || event === "update")) {
       void extractCssImportDependencies(ctx, filePath);
     }
-    const shouldInvalidate = event === "create" && ready || event === "delete";
+    const isDeleteEvent = event === "delete";
+    const shouldInvalidate = event === "create" && ready || isDeleteEvent;
     if (shouldInvalidate) {
       void (async () => {
         await invalidateEntryForSidecar(ctx, filePath, event);
-        if (isCssFile && event === "delete") {
+        if (isCssFile && isDeleteEvent) {
           cleanupImporterGraph(ctx, filePath);
         }
       })();
       return;
     }
-    if (isCssFile && event === "delete") {
+    if (isCssFile && isDeleteEvent) {
       cleanupImporterGraph(ctx, filePath);
     }
   };
   const patterns = [
     ...configExtensions.map((ext2) => _pathe2.default.join(absRoot, `**/*.${ext2}`)),
-    ...supportedCssLangs.map((ext2) => _pathe2.default.join(absRoot, `**/*.${ext2}`))
+    ...supportedCssLangs.map((ext2) => _pathe2.default.join(absRoot, `**/*.${ext2}`)),
+    ...templateExtensions.map((ext2) => _pathe2.default.join(absRoot, `**/*.${ext2}`))
   ];
   const watcher = esm_default.watch(patterns, {
     ignoreInitial: false,
@@ -23271,11 +23315,15 @@ function ensureSidecarWatcher(ctx, rootDir) {
       pollInterval: 20
     }
   });
-  const forwardChange = (event, input) => {
+  const forwardChange = (event, input, options) => {
     if (!input) {
       return;
     }
-    handleSidecarChange(event, _pathe2.default.normalize(input), isReady);
+    const normalizedPath = _pathe2.default.normalize(input);
+    if (!_optionalChain([options, 'optionalAccess', _365 => _365.silent])) {
+      logger_default.info(`[watch:${event}] ${ctx.configService.relativeCwd(normalizedPath)}`);
+    }
+    handleSidecarChange(event, normalizedPath, isReady);
   };
   watcher.on("add", (path36) => forwardChange("create", path36));
   watcher.on("change", (path36) => forwardChange("update", path36));
@@ -23290,7 +23338,11 @@ function ensureSidecarWatcher(ctx, rootDir) {
     }
     const baseDir = typeof details === "object" && details && "watchedPath" in details ? _nullishCoalesce(details.watchedPath, () => ( absRoot)) : absRoot;
     const resolved = _pathe2.default.isAbsolute(candidate) ? candidate : _pathe2.default.resolve(baseDir, candidate);
-    forwardChange("create", resolved);
+    const exists = actualFS.default.existsSync(resolved);
+    const derivedEvent = exists ? "create" : "delete";
+    const relativeResolved = ctx.configService.relativeCwd(resolved);
+    logger_default.info(`[watch:rename->${derivedEvent}] ${relativeResolved}`);
+    forwardChange(derivedEvent, resolved, { silent: true });
   });
   watcher.on("ready", () => {
     isReady = true;
@@ -23300,16 +23352,13 @@ function ensureSidecarWatcher(ctx, rootDir) {
       return;
     }
     const relativeRoot = ctx.configService.relativeCwd(absRoot);
-    const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _365 => _365.code]), () => ( "UNKNOWN"));
+    const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _366 => _366.code]), () => ( "UNKNOWN"));
     logger_default.warn(`[watch] ${relativeRoot} \u76D1\u542C\u6570\u91CF\u8FBE\u5230\u4E0A\u9650 (${code})\uFF0C\u4FA7\u8F66\u6587\u4EF6\u76D1\u542C\u5DF2\u505C\u7528`);
   });
   sidecarWatcherMap.set(absRoot, {
     close: () => void watcher.close()
   });
 }
-function isSidecarFile(filePath) {
-  return sidecarSuffixes.some((suffix) => filePath.endsWith(suffix));
-}
 
 // src/plugins/utils/parse.ts
 _chunkWWFEREWVcjs.init_cjs_shims.call(void 0, );
@@ -23467,7 +23516,7 @@ function createCacheKey(options) {
   return `${options.removeComment ? 1 : 0}|${options.transformEvent ? 1 : 0}`;
 }
 function getCachedResult(data2, cacheKey) {
-  return _optionalChain([handleCache, 'access', _366 => _366.get, 'call', _367 => _367(data2), 'optionalAccess', _368 => _368.get, 'call', _369 => _369(cacheKey)]);
+  return _optionalChain([handleCache, 'access', _367 => _367.get, 'call', _368 => _368(data2), 'optionalAccess', _369 => _369.get, 'call', _370 => _370(cacheKey)]);
 }
 function setCachedResult(data2, cacheKey, result) {
   let cacheForToken = handleCache.get(data2);
@@ -23543,7 +23592,7 @@ function handleWxml(data2, options) {
   if (shouldTransformInlineWxs) {
     for (const { end, start, value } of inlineWxsTokens) {
       const { result } = getCachedInlineWxsTransform(value);
-      if (_optionalChain([result, 'optionalAccess', _370 => _370.code])) {
+      if (_optionalChain([result, 'optionalAccess', _371 => _371.code])) {
         ms.update(start, end, `
 ${result.code}`);
       }
@@ -23594,11 +23643,11 @@ function emitWxmlAssetsWithCache(options) {
   });
   const emittedFiles = [];
   for (const { id, fileName, token } of currentPackageWxmls) {
-    _optionalChain([runtime, 'access', _371 => _371.addWatchFile, 'optionalCall', _372 => _372(id)]);
+    _optionalChain([runtime, 'access', _372 => _372.addWatchFile, 'optionalCall', _373 => _373(id)]);
     const deps = wxmlService.depsMap.get(id);
     if (deps) {
       for (const dep of deps) {
-        _optionalChain([runtime, 'access', _373 => _373.addWatchFile, 'optionalCall', _374 => _374(dep)]);
+        _optionalChain([runtime, 'access', _374 => _374.addWatchFile, 'optionalCall', _375 => _375(dep)]);
       }
     }
     emittedFiles.push(fileName);
@@ -23694,7 +23743,7 @@ function createCoreLifecyclePlugin(state) {
           buildService.invalidateIndependentOutput(independentRoot);
           scanService.markIndependentDirty(independentRoot);
           handledByIndependentWatcher = true;
-          if (_optionalChain([independentMeta, 'optionalAccess', _375 => _375.watchSharedStyles]) !== false) {
+          if (_optionalChain([independentMeta, 'optionalAccess', _376 => _376.watchSharedStyles]) !== false) {
             invalidateSharedStyleCache();
           }
         }
@@ -23742,7 +23791,7 @@ function createCoreLifecyclePlugin(state) {
       options.input = scannedInput;
     },
     async load(id) {
-      _optionalChain([configService, 'access', _376 => _376.weappViteConfig, 'optionalAccess', _377 => _377.debug, 'optionalAccess', _378 => _378.load, 'optionalCall', _379 => _379(id, subPackageMeta)]);
+      _optionalChain([configService, 'access', _377 => _377.weappViteConfig, 'optionalAccess', _378 => _378.debug, 'optionalAccess', _379 => _379.load, 'optionalCall', _380 => _380(id, subPackageMeta)]);
       const relativeBasename = _shared.removeExtensionDeep.call(void 0, configService.relativeAbsoluteSrcRoot(id));
       if (isCSSRequest(id)) {
         const parsed = parseRequest(id);
@@ -23756,7 +23805,7 @@ function createCoreLifecyclePlugin(state) {
         }
         return null;
       }
-      if (loadedEntrySet.has(id) || _optionalChain([subPackageMeta, 'optionalAccess', _380 => _380.entries, 'access', _381 => _381.includes, 'call', _382 => _382(relativeBasename)])) {
+      if (loadedEntrySet.has(id) || _optionalChain([subPackageMeta, 'optionalAccess', _381 => _381.entries, 'access', _382 => _382.includes, 'call', _383 => _383(relativeBasename)])) {
         return await loadEntry.call(this, id, "component");
       }
       if (relativeBasename === "app") {
@@ -23787,8 +23836,8 @@ function createCoreLifecyclePlugin(state) {
           return subPackageRoots.find((root) => filePath === root || filePath.startsWith(`${root}/`));
         };
         var matchSubPackage = matchSubPackage2;
-        const sharedStrategy = _nullishCoalesce(_optionalChain([configService, 'access', _383 => _383.weappViteConfig, 'optionalAccess', _384 => _384.chunks, 'optionalAccess', _385 => _385.sharedStrategy]), () => ( DEFAULT_SHARED_CHUNK_STRATEGY));
-        const shouldLogChunks = _nullishCoalesce(_optionalChain([configService, 'access', _386 => _386.weappViteConfig, 'optionalAccess', _387 => _387.chunks, 'optionalAccess', _388 => _388.logOptimization]), () => ( true));
+        const sharedStrategy = _nullishCoalesce(_optionalChain([configService, 'access', _384 => _384.weappViteConfig, 'optionalAccess', _385 => _385.chunks, 'optionalAccess', _386 => _386.sharedStrategy]), () => ( DEFAULT_SHARED_CHUNK_STRATEGY));
+        const shouldLogChunks = _nullishCoalesce(_optionalChain([configService, 'access', _387 => _387.weappViteConfig, 'optionalAccess', _388 => _388.chunks, 'optionalAccess', _389 => _389.logOptimization]), () => ( true));
         const subPackageRoots = Array.from(scanService.subPackageMap.keys()).filter(Boolean);
         applySharedChunkStrategy.call(this, bundle, {
           strategy: sharedStrategy,
@@ -23833,10 +23882,10 @@ function createCoreLifecyclePlugin(state) {
           } : void 0
         });
       }
-      if (_optionalChain([configService, 'access', _389 => _389.weappViteConfig, 'optionalAccess', _390 => _390.debug, 'optionalAccess', _391 => _391.watchFiles])) {
+      if (_optionalChain([configService, 'access', _390 => _390.weappViteConfig, 'optionalAccess', _391 => _391.debug, 'optionalAccess', _392 => _392.watchFiles])) {
         const watcherService = ctx.watcherService;
-        const watcherRoot = _nullishCoalesce(_optionalChain([subPackageMeta, 'optionalAccess', _392 => _392.subPackage, 'access', _393 => _393.root]), () => ( "/"));
-        const watcher = _optionalChain([watcherService, 'optionalAccess', _394 => _394.getRollupWatcher, 'call', _395 => _395(watcherRoot)]);
+        const watcherRoot = _nullishCoalesce(_optionalChain([subPackageMeta, 'optionalAccess', _393 => _393.subPackage, 'access', _394 => _394.root]), () => ( "/"));
+        const watcher = _optionalChain([watcherService, 'optionalAccess', _395 => _395.getRollupWatcher, 'call', _396 => _396(watcherRoot)]);
         let watchFiles;
         if (watcher && typeof watcher.getWatchFiles === "function") {
           watchFiles = await watcher.getWatchFiles();
@@ -23850,7 +23899,7 @@ function createCoreLifecyclePlugin(state) {
       }
     },
     buildEnd() {
-      _optionalChain([debug2, 'optionalCall', _396 => _396(`${subPackageMeta ? `\u72EC\u7ACB\u5206\u5305 ${subPackageMeta.subPackage.root}` : "\u4E3B\u5305"} ${Array.from(this.getModuleIds()).length} \u4E2A\u6A21\u5757\u88AB\u7F16\u8BD1`)]);
+      _optionalChain([debug2, 'optionalCall', _397 => _397(`${subPackageMeta ? `\u72EC\u7ACB\u5206\u5305 ${subPackageMeta.subPackage.root}` : "\u4E3B\u5305"} ${Array.from(this.getModuleIds()).length} \u4E2A\u6A21\u5757\u88AB\u7F16\u8BD1`)]);
     }
   };
 }
@@ -23934,7 +23983,7 @@ async function flushIndependentBuilds(state) {
   }
   const outputs = await Promise.all(pendingIndependentBuilds);
   for (const { rollup } of outputs) {
-    const bundleOutputs = Array.isArray(_optionalChain([rollup, 'optionalAccess', _397 => _397.output])) ? rollup.output : [];
+    const bundleOutputs = Array.isArray(_optionalChain([rollup, 'optionalAccess', _398 => _398.output])) ? rollup.output : [];
     for (const output of bundleOutputs) {
       if (output.type === "chunk") {
         this.emitFile({
@@ -23971,13 +24020,13 @@ function toPosixPath(value) {
 var styleMatcherCache = /* @__PURE__ */ new WeakMap();
 function collectSharedStyleEntries(ctx, configService) {
   const map = /* @__PURE__ */ new Map();
-  const registry = _optionalChain([ctx, 'access', _398 => _398.scanService, 'optionalAccess', _399 => _399.subPackageMap]);
-  if (!_optionalChain([registry, 'optionalAccess', _400 => _400.size])) {
+  const registry = _optionalChain([ctx, 'access', _399 => _399.scanService, 'optionalAccess', _400 => _400.subPackageMap]);
+  if (!_optionalChain([registry, 'optionalAccess', _401 => _401.size])) {
     return map;
   }
   const currentRoot = configService.currentSubPackageRoot;
   for (const [root, meta] of registry.entries()) {
-    if (!_optionalChain([meta, 'access', _401 => _401.styleEntries, 'optionalAccess', _402 => _402.length])) {
+    if (!_optionalChain([meta, 'access', _402 => _402.styleEntries, 'optionalAccess', _403 => _403.length])) {
       continue;
     }
     if (currentRoot && root !== currentRoot) {
@@ -24022,12 +24071,12 @@ function getStyleMatcher(entry) {
   if (cached) {
     return cached;
   }
-  const includePatterns = _optionalChain([entry, 'access', _403 => _403.include, 'optionalAccess', _404 => _404.length]) ? entry.include : ["**/*"];
-  const excludePatterns = _optionalChain([entry, 'access', _405 => _405.exclude, 'optionalAccess', _406 => _406.length]) ? entry.exclude : void 0;
+  const includePatterns = _optionalChain([entry, 'access', _404 => _404.include, 'optionalAccess', _405 => _405.length]) ? entry.include : ["**/*"];
+  const excludePatterns = _optionalChain([entry, 'access', _406 => _406.exclude, 'optionalAccess', _407 => _407.length]) ? entry.exclude : void 0;
   const matcher = {
     include: _picomatch2.default.call(void 0, includePatterns, { dot: true })
   };
-  if (_optionalChain([excludePatterns, 'optionalAccess', _407 => _407.length])) {
+  if (_optionalChain([excludePatterns, 'optionalAccess', _408 => _408.length])) {
     matcher.exclude = _picomatch2.default.call(void 0, excludePatterns, { dot: true });
   }
   styleMatcherCache.set(entry, matcher);
@@ -24132,7 +24181,7 @@ function injectSharedStyleImports(css2, modulePath, fileName, sharedStyles, conf
   }
   const normalizedFileName = toPosixPath(fileName);
   const entries = findSharedStylesForModule(normalizedModule, normalizedFileName, sharedStyles);
-  if (!_optionalChain([entries, 'optionalAccess', _408 => _408.length])) {
+  if (!_optionalChain([entries, 'optionalAccess', _409 => _409.length])) {
     return css2;
   }
   const specifiers = resolveImportSpecifiers(fileName, entries);
@@ -24339,22 +24388,19 @@ _chunkWWFEREWVcjs.init_cjs_shims.call(void 0, );
 
 var debug3 = createDebugger("weapp-vite:preflight");
 var removePlugins = ["vite:build-import-analysis"];
-function preflight(ctx) {
-  return [createPluginPruner(), createEnvSynchronizer(ctx)];
-}
 function createPluginPruner() {
   return {
     name: "weapp-vite:preflight",
     enforce: "pre",
     configResolved(config) {
-      if (!_optionalChain([config, 'access', _409 => _409.plugins, 'optionalAccess', _410 => _410.length])) {
+      if (!_optionalChain([config, 'access', _410 => _410.plugins, 'optionalAccess', _411 => _411.length])) {
         return;
       }
       for (const removePlugin of removePlugins) {
         const idx = config.plugins.findIndex((plugin) => plugin.name === removePlugin);
         if (idx > -1) {
           const [plugin] = config.plugins.splice(idx, 1);
-          plugin && _optionalChain([debug3, 'optionalCall', _411 => _411("remove plugin", plugin.name)]);
+          plugin && _optionalChain([debug3, 'optionalCall', _412 => _412("remove plugin", plugin.name)]);
         }
       }
     }
@@ -24374,6 +24420,9 @@ function createEnvSynchronizer({ configService }) {
     }
   };
 }
+function preflight(ctx) {
+  return [createPluginPruner(), createEnvSynchronizer(ctx)];
+}
 
 // src/plugins/workers.ts
 _chunkWWFEREWVcjs.init_cjs_shims.call(void 0, );
@@ -24381,11 +24430,25 @@ _chunkWWFEREWVcjs.init_cjs_shims.call(void 0, );
 
 
 
-function workers(ctx) {
-  if (!ctx.scanService.workersDir) {
-    return [];
+async function resolveWorkerEntry(ctx, entry) {
+  const { configService, scanService } = ctx;
+  const relativeEntryPath = _pathe2.default.join(scanService.workersDir, entry);
+  const key = _shared.removeExtension.call(void 0, relativeEntryPath);
+  const absoluteEntry = _pathe2.default.resolve(configService.absoluteSrcRoot, relativeEntryPath);
+  if (isJsOrTs(entry)) {
+    const exists = await _fsextra2.default.exists(absoluteEntry);
+    if (!exists) {
+      logger_default.warn(`\u5F15\u7528 worker: \`${configService.relativeCwd(relativeEntryPath)}\` \u4E0D\u5B58\u5728!`);
+      return { key };
+    }
+    return { key, value: absoluteEntry };
   }
-  return [createWorkerBuildPlugin(ctx)];
+  const { path: discovered } = await findJsEntry(absoluteEntry);
+  if (!discovered) {
+    logger_default.warn(`\u5F15\u7528 worker: \`${configService.relativeCwd(relativeEntryPath)}\` \u4E0D\u5B58\u5728!`);
+    return { key };
+  }
+  return { key, value: discovered };
 }
 function createWorkerBuildPlugin(ctx) {
   const { configService, scanService } = ctx;
@@ -24393,8 +24456,8 @@ function createWorkerBuildPlugin(ctx) {
     name: "weapp-vite:workers",
     enforce: "pre",
     async options(options) {
-      const workerConfig = _optionalChain([configService, 'access', _412 => _412.weappViteConfig, 'optionalAccess', _413 => _413.worker]);
-      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _414 => _414.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _415 => _415.entry])];
+      const workerConfig = _optionalChain([configService, 'access', _413 => _413.weappViteConfig, 'optionalAccess', _414 => _414.worker]);
+      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _415 => _415.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _416 => _416.entry])];
       const normalized = (await Promise.all(entries.filter(Boolean).map((entry) => resolveWorkerEntry(ctx, entry)))).filter((result) => Boolean(result.value)).reduce((acc, cur) => {
         acc[cur.key] = cur.value;
         return acc;
@@ -24418,25 +24481,11 @@ function createWorkerBuildPlugin(ctx) {
     }
   };
 }
-async function resolveWorkerEntry(ctx, entry) {
-  const { configService, scanService } = ctx;
-  const relativeEntryPath = _pathe2.default.join(scanService.workersDir, entry);
-  const key = _shared.removeExtension.call(void 0, relativeEntryPath);
-  const absoluteEntry = _pathe2.default.resolve(configService.absoluteSrcRoot, relativeEntryPath);
-  if (isJsOrTs(entry)) {
-    const exists = await _fsextra2.default.exists(absoluteEntry);
-    if (!exists) {
-      logger_default.warn(`\u5F15\u7528 worker: \`${configService.relativeCwd(relativeEntryPath)}\` \u4E0D\u5B58\u5728!`);
-      return { key };
-    }
-    return { key, value: absoluteEntry };
-  }
-  const { path: discovered } = await findJsEntry(absoluteEntry);
-  if (!discovered) {
-    logger_default.warn(`\u5F15\u7528 worker: \`${configService.relativeCwd(relativeEntryPath)}\` \u4E0D\u5B58\u5728!`);
-    return { key };
+function workers(ctx) {
+  if (!ctx.scanService.workersDir) {
+    return [];
   }
-  return { key, value: discovered };
+  return [createWorkerBuildPlugin(ctx)];
 }
 
 // src/plugins/wxs.ts
@@ -24447,52 +24496,6 @@ _chunkWWFEREWVcjs.init_cjs_shims.call(void 0, );
 var wxsCodeCache = new LRUCache({
   max: 512
 });
-function wxs(ctx) {
-  const state = {
-    ctx,
-    wxsMap: /* @__PURE__ */ new Map()
-  };
-  return [createWxsPlugin(state)];
-}
-function createWxsPlugin(state) {
-  const { ctx } = state;
-  const { wxmlService } = ctx;
-  return {
-    name: "weapp-vite:wxs",
-    enforce: "pre",
-    buildStart() {
-      state.wxsMap.clear();
-    },
-    async buildEnd() {
-      await Promise.all(
-        Array.from(wxmlService.tokenMap.entries()).map(([id, token]) => {
-          return handleWxsDeps.call(
-            // @ts-ignore rolldown context
-            this,
-            state,
-            token.deps,
-            id
-          );
-        })
-      );
-      for (const { emittedFile } of state.wxsMap.values()) {
-        this.emitFile(emittedFile);
-      }
-    }
-  };
-}
-async function handleWxsDeps(state, deps, absPath) {
-  await Promise.all(
-    deps.filter((dep) => dep.tagName === "wxs").map(async (dep) => {
-      const arr = dep.value.match(/\.wxs(\.[jt]s)?$/);
-      if (!jsExtensions.includes(dep.attrs.lang) && !arr) {
-        return;
-      }
-      const wxsPath = _pathe2.default.resolve(_pathe2.default.dirname(absPath), dep.value);
-      await transformWxsFile.call(this, state, wxsPath);
-    })
-  );
-}
 async function transformWxsFile(state, wxsPath) {
   const { ctx } = state;
   const { configService } = ctx;
@@ -24511,7 +24514,7 @@ async function transformWxsFile(state, wxsPath) {
     const { result, importees } = transformWxsCode(rawCode, {
       filename: wxsPath
     });
-    if (typeof _optionalChain([result, 'optionalAccess', _416 => _416.code]) === "string") {
+    if (typeof _optionalChain([result, 'optionalAccess', _417 => _417.code]) === "string") {
       code = result.code;
     }
     const dirname5 = _pathe2.default.dirname(wxsPath);
@@ -24539,18 +24542,64 @@ async function transformWxsFile(state, wxsPath) {
   });
   wxsCodeCache.set(rawCode, code);
 }
+async function handleWxsDeps(state, deps, absPath) {
+  await Promise.all(
+    deps.filter((dep) => dep.tagName === "wxs").map(async (dep) => {
+      const arr = dep.value.match(/\.wxs(\.[jt]s)?$/);
+      if (!jsExtensions.includes(dep.attrs.lang) && !arr) {
+        return;
+      }
+      const wxsPath = _pathe2.default.resolve(_pathe2.default.dirname(absPath), dep.value);
+      await transformWxsFile.call(this, state, wxsPath);
+    })
+  );
+}
+function createWxsPlugin(state) {
+  const { ctx } = state;
+  const { wxmlService } = ctx;
+  return {
+    name: "weapp-vite:wxs",
+    enforce: "pre",
+    buildStart() {
+      state.wxsMap.clear();
+    },
+    async buildEnd() {
+      await Promise.all(
+        Array.from(wxmlService.tokenMap.entries()).map(([id, token]) => {
+          return handleWxsDeps.call(
+            // @ts-ignore rolldown context
+            this,
+            state,
+            token.deps,
+            id
+          );
+        })
+      );
+      for (const { emittedFile } of state.wxsMap.values()) {
+        this.emitFile(emittedFile);
+      }
+    }
+  };
+}
+function wxs(ctx) {
+  const state = {
+    ctx,
+    wxsMap: /* @__PURE__ */ new Map()
+  };
+  return [createWxsPlugin(state)];
+}
 
 // src/plugins/index.ts
 var RUNTIME_PLUGINS_SYMBOL = Symbol.for("weapp-runtime:plugins");
 function attachRuntimePlugins(ctx, plugins) {
   const runtimePlugins = ctx[RUNTIME_PLUGINS_SYMBOL];
-  if (!_optionalChain([runtimePlugins, 'optionalAccess', _417 => _417.length])) {
+  if (!_optionalChain([runtimePlugins, 'optionalAccess', _418 => _418.length])) {
     return plugins;
   }
   return [...runtimePlugins, ...plugins];
 }
 function applyInspect(ctx, plugins) {
-  const inspectOptions = _optionalChain([ctx, 'access', _418 => _418.configService, 'access', _419 => _419.weappViteConfig, 'optionalAccess', _420 => _420.debug, 'optionalAccess', _421 => _421.inspect]);
+  const inspectOptions = _optionalChain([ctx, 'access', _419 => _419.configService, 'access', _420 => _420.weappViteConfig, 'optionalAccess', _421 => _421.debug, 'optionalAccess', _422 => _422.inspect]);
   if (!inspectOptions) {
     return plugins;
   }
@@ -24641,7 +24690,7 @@ function createMergeFactories(options) {
     const currentOptions = getOptions2();
     applyRuntimePlatform("miniprogram");
     const external = [];
-    if (_optionalChain([currentOptions, 'access', _422 => _422.packageJson, 'optionalAccess', _423 => _423.dependencies])) {
+    if (_optionalChain([currentOptions, 'access', _423 => _423.packageJson, 'optionalAccess', _424 => _424.dependencies])) {
       external.push(
         ...Object.keys(currentOptions.packageJson.dependencies).map((pkg) => {
           return new RegExp(`^${pkg.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}(\\/|$)`);
@@ -24656,7 +24705,7 @@ function createMergeFactories(options) {
       const watchInclude = [
         _pathe2.default.join(currentOptions.cwd, currentOptions.srcRoot, "**")
       ];
-      const pluginRootConfig = _optionalChain([currentOptions, 'access', _424 => _424.config, 'access', _425 => _425.weapp, 'optionalAccess', _426 => _426.pluginRoot]);
+      const pluginRootConfig = _optionalChain([currentOptions, 'access', _425 => _425.config, 'access', _426 => _426.weapp, 'optionalAccess', _427 => _427.pluginRoot]);
       if (pluginRootConfig) {
         const absolutePluginRoot = _pathe2.default.resolve(currentOptions.cwd, pluginRootConfig);
         const relativeToSrc = _pathe2.default.relative(
@@ -24716,7 +24765,7 @@ function createMergeFactories(options) {
     );
     inlineConfig.logLevel = "info";
     injectBuiltinAliases(inlineConfig);
-    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _427 => _427.subPackage, 'access', _428 => _428.root]);
+    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _428 => _428.subPackage, 'access', _429 => _429.root]);
     setOptions({
       ...currentOptions,
       currentSubPackageRoot: currentRoot
@@ -24727,7 +24776,7 @@ function createMergeFactories(options) {
     ensureConfigService();
     const currentOptions = getOptions2();
     const web = currentOptions.weappWeb;
-    if (!_optionalChain([web, 'optionalAccess', _429 => _429.enabled])) {
+    if (!_optionalChain([web, 'optionalAccess', _430 => _430.enabled])) {
       return void 0;
     }
     applyRuntimePlatform("web");
@@ -24818,7 +24867,7 @@ function createConfigService(ctx) {
     defineEnv[key] = value;
   }
   function getDefineImportMetaEnv() {
-    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _430 => _430.platform]), () => ( DEFAULT_MP_PLATFORM));
+    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _431 => _431.platform]), () => ( DEFAULT_MP_PLATFORM));
     const resolvedPlatform = _nullishCoalesce(defineEnv.PLATFORM, () => ( mpPlatform));
     const env = {
       PLATFORM: resolvedPlatform,
@@ -24834,7 +24883,7 @@ function createConfigService(ctx) {
   }
   function applyRuntimePlatform(runtime) {
     const isWeb = runtime === "web";
-    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _431 => _431.platform]), () => ( DEFAULT_MP_PLATFORM));
+    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _432 => _432.platform]), () => ( DEFAULT_MP_PLATFORM));
     const resolvedPlatform = isWeb ? "web" : mpPlatform;
     setDefineEnv("PLATFORM", resolvedPlatform);
     setDefineEnv("IS_WEB", isWeb);
@@ -24945,10 +24994,10 @@ function createConfigService(ctx) {
       return options.srcRoot;
     },
     get pluginRoot() {
-      return _optionalChain([options, 'access', _432 => _432.config, 'access', _433 => _433.weapp, 'optionalAccess', _434 => _434.pluginRoot]);
+      return _optionalChain([options, 'access', _433 => _433.config, 'access', _434 => _434.weapp, 'optionalAccess', _435 => _435.pluginRoot]);
     },
     get absolutePluginRoot() {
-      if (_optionalChain([options, 'access', _435 => _435.config, 'access', _436 => _436.weapp, 'optionalAccess', _437 => _437.pluginRoot])) {
+      if (_optionalChain([options, 'access', _436 => _436.config, 'access', _437 => _437.weapp, 'optionalAccess', _438 => _438.pluginRoot])) {
         return _pathe2.default.resolve(options.cwd, options.config.weapp.pluginRoot);
       }
     },
@@ -24978,7 +25027,7 @@ function createConfigService(ctx) {
     },
     relativeAbsoluteSrcRoot(p) {
       const absoluteSrcRoot = _pathe2.default.resolve(options.cwd, options.srcRoot);
-      const pluginRootConfig = _optionalChain([options, 'access', _438 => _438.config, 'access', _439 => _439.weapp, 'optionalAccess', _440 => _440.pluginRoot]);
+      const pluginRootConfig = _optionalChain([options, 'access', _439 => _439.config, 'access', _440 => _440.weapp, 'optionalAccess', _441 => _441.pluginRoot]);
       if (pluginRootConfig) {
         const absolutePluginRoot = _pathe2.default.resolve(options.cwd, pluginRootConfig);
         const relativeToPlugin = _pathe2.default.relative(absolutePluginRoot, p);
@@ -25030,10 +25079,10 @@ function createJsonService(ctx) {
       }
       let resultJson;
       if (/app\.json(?:\.[jt]s)?$/.test(filepath)) {
-        await _optionalChain([ctx, 'access', _441 => _441.autoRoutesService, 'optionalAccess', _442 => _442.ensureFresh, 'call', _443 => _443()]);
+        await _optionalChain([ctx, 'access', _442 => _442.autoRoutesService, 'optionalAccess', _443 => _443.ensureFresh, 'call', _444 => _444()]);
       }
       if (/\.json\.[jt]s$/.test(filepath)) {
-        const routesReference = _optionalChain([ctx, 'access', _444 => _444.autoRoutesService, 'optionalAccess', _445 => _445.getReference, 'call', _446 => _446()]);
+        const routesReference = _optionalChain([ctx, 'access', _445 => _445.autoRoutesService, 'optionalAccess', _446 => _446.getReference, 'call', _447 => _447()]);
         const fallbackRoutes = _nullishCoalesce(routesReference, () => ( { pages: [], entries: [], subPackages: [] }));
         const routesModule = {
           routes: fallbackRoutes,
@@ -25082,7 +25131,7 @@ function createJsonService(ctx) {
       return resultJson;
     } catch (error) {
       logger_default.error(`\u6B8B\u7834\u7684JSON\u6587\u4EF6: ${filepath}`);
-      _optionalChain([debug, 'optionalCall', _447 => _447(error)]);
+      _optionalChain([debug, 'optionalCall', _448 => _448(error)]);
     }
   }
   function resolve8(entry) {
@@ -25137,7 +25186,7 @@ function createNpmService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before writing npm cache");
     }
-    if (_optionalChain([ctx, 'access', _448 => _448.configService, 'access', _449 => _449.weappViteConfig, 'optionalAccess', _450 => _450.npm, 'optionalAccess', _451 => _451.cache])) {
+    if (_optionalChain([ctx, 'access', _449 => _449.configService, 'access', _450 => _450.weappViteConfig, 'optionalAccess', _451 => _451.npm, 'optionalAccess', _452 => _452.cache])) {
       await _fsextra2.default.outputJSON(getDependenciesCacheFilePath(root), {
         hash: dependenciesCacheHash()
       });
@@ -25150,7 +25199,7 @@ function createNpmService(ctx) {
     }
   }
   async function checkDependenciesCacheOutdate(root) {
-    if (_optionalChain([ctx, 'access', _452 => _452.configService, 'optionalAccess', _453 => _453.weappViteConfig, 'optionalAccess', _454 => _454.npm, 'optionalAccess', _455 => _455.cache])) {
+    if (_optionalChain([ctx, 'access', _453 => _453.configService, 'optionalAccess', _454 => _454.weappViteConfig, 'optionalAccess', _455 => _455.npm, 'optionalAccess', _456 => _456.cache])) {
       const json = await readDependenciesCache(root);
       if (_shared.isObject.call(void 0, json)) {
         return dependenciesCacheHash() !== json.hash;
@@ -25183,7 +25232,7 @@ function createNpmService(ctx) {
       target: "es6",
       external: []
     });
-    const resolvedOptions = _optionalChain([ctx, 'access', _456 => _456.configService, 'optionalAccess', _457 => _457.weappViteConfig, 'optionalAccess', _458 => _458.npm, 'optionalAccess', _459 => _459.buildOptions, 'optionalCall', _460 => _460(
+    const resolvedOptions = _optionalChain([ctx, 'access', _457 => _457.configService, 'optionalAccess', _458 => _458.weappViteConfig, 'optionalAccess', _459 => _459.npm, 'optionalAccess', _460 => _460.buildOptions, 'optionalCall', _461 => _461(
       mergedOptions,
       { name, entry }
     )]);
@@ -25283,7 +25332,7 @@ function createNpmService(ctx) {
       throw new Error("configService must be initialized before resolving npm relation list");
     }
     let packNpmRelationList = [];
-    if (_optionalChain([ctx, 'access', _461 => _461.configService, 'access', _462 => _462.projectConfig, 'access', _463 => _463.setting, 'optionalAccess', _464 => _464.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
+    if (_optionalChain([ctx, 'access', _462 => _462.configService, 'access', _463 => _463.projectConfig, 'access', _464 => _464.setting, 'optionalAccess', _465 => _465.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
       packNpmRelationList = ctx.configService.projectConfig.setting.packNpmRelationList;
     } else {
       packNpmRelationList = [
@@ -25296,10 +25345,10 @@ function createNpmService(ctx) {
     return packNpmRelationList;
   }
   async function build3(options) {
-    if (!_optionalChain([ctx, 'access', _465 => _465.configService, 'optionalAccess', _466 => _466.weappViteConfig, 'optionalAccess', _467 => _467.npm, 'optionalAccess', _468 => _468.enable])) {
+    if (!_optionalChain([ctx, 'access', _466 => _466.configService, 'optionalAccess', _467 => _467.weappViteConfig, 'optionalAccess', _468 => _468.npm, 'optionalAccess', _469 => _469.enable])) {
       return;
     }
-    _optionalChain([debug, 'optionalCall', _469 => _469("buildNpm start")]);
+    _optionalChain([debug, 'optionalCall', _470 => _470("buildNpm start")]);
     const packNpmRelationList = getPackNpmRelationList();
     const [mainRelation, ...subRelations] = packNpmRelationList;
     const packageJsonPath = _pathe2.default.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
@@ -25374,7 +25423,7 @@ function createNpmService(ctx) {
         }
       }
     }
-    _optionalChain([debug, 'optionalCall', _470 => _470("buildNpm end")]);
+    _optionalChain([debug, 'optionalCall', _471 => _471("buildNpm end")]);
   }
   return {
     getDependenciesCacheFilePath,
@@ -25418,7 +25467,7 @@ var TimeoutError = (_class16 = class _TimeoutError extends Error {
   __init36() {this.name = "TimeoutError"}
   constructor(message, options) {
     super(message, options);_class16.prototype.__init36.call(this);;
-    _optionalChain([Error, 'access', _471 => _471.captureStackTrace, 'optionalCall', _472 => _472(this, _TimeoutError)]);
+    _optionalChain([Error, 'access', _472 => _472.captureStackTrace, 'optionalCall', _473 => _473(this, _TimeoutError)]);
   }
 }, _class16);
 var getAbortedReason = (signal) => _nullishCoalesce(signal.reason, () => ( new DOMException("This operation was aborted.", "AbortError")));
@@ -25436,7 +25485,7 @@ function pTimeout(promise, options) {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
-    if (_optionalChain([signal, 'optionalAccess', _473 => _473.aborted])) {
+    if (_optionalChain([signal, 'optionalAccess', _474 => _474.aborted])) {
       reject(getAbortedReason(signal));
       return;
     }
@@ -25534,7 +25583,7 @@ var PriorityQueue = class {
   }
   dequeue() {
     const item = this.#queue.shift();
-    return _optionalChain([item, 'optionalAccess', _474 => _474.run]);
+    return _optionalChain([item, 'optionalAccess', _475 => _475.run]);
   }
   filter(options) {
     return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
@@ -25595,10 +25644,10 @@ var PQueue = class extends import_index2.default {
       ...options
     };
     if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
-      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _475 => _475.intervalCap, 'optionalAccess', _476 => _476.toString, 'call', _477 => _477()]), () => ( ""))}\` (${typeof options.intervalCap})`);
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _476 => _476.intervalCap, 'optionalAccess', _477 => _477.toString, 'call', _478 => _478()]), () => ( ""))}\` (${typeof options.intervalCap})`);
     }
     if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
-      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _478 => _478.interval, 'optionalAccess', _479 => _479.toString, 'call', _480 => _480()]), () => ( ""))}\` (${typeof options.interval})`);
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _479 => _479.interval, 'optionalAccess', _480 => _480.toString, 'call', _481 => _481()]), () => ( ""))}\` (${typeof options.interval})`);
     }
     this.#carryoverIntervalCount = _nullishCoalesce(_nullishCoalesce(options.carryoverIntervalCount, () => ( options.carryoverConcurrencyCount)), () => ( false));
     this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
@@ -25805,7 +25854,7 @@ var PQueue = class extends import_index2.default {
         });
         try {
           try {
-            _optionalChain([options, 'access', _481 => _481.signal, 'optionalAccess', _482 => _482.throwIfAborted, 'call', _483 => _483()]);
+            _optionalChain([options, 'access', _482 => _482.signal, 'optionalAccess', _483 => _483.throwIfAborted, 'call', _484 => _484()]);
           } catch (error) {
             if (!this.#isIntervalIgnored) {
               this.#intervalCount--;
@@ -26178,7 +26227,7 @@ var FileCache = class {
       return true;
     }
     const cachedMtime = this.mtimeMap.get(id);
-    const nextSignature = _optionalChain([options, 'optionalAccess', _484 => _484.content]) !== void 0 ? createSignature(options.content) : void 0;
+    const nextSignature = _optionalChain([options, 'optionalAccess', _485 => _485.content]) !== void 0 ? createSignature(options.content) : void 0;
     const updateSignature = () => {
       if (nextSignature !== void 0) {
         this.signatureMap.set(id, nextSignature);
@@ -26413,7 +26462,7 @@ function coerceStyleConfig(entry) {
   if (!entry || typeof entry !== "object") {
     return void 0;
   }
-  const source = _optionalChain([entry, 'access', _485 => _485.source, 'optionalAccess', _486 => _486.toString, 'call', _487 => _487(), 'access', _488 => _488.trim, 'call', _489 => _489()]);
+  const source = _optionalChain([entry, 'access', _486 => _486.source, 'optionalAccess', _487 => _487.toString, 'call', _488 => _488(), 'access', _489 => _489.trim, 'call', _490 => _490()]);
   if (!source) {
     return void 0;
   }
@@ -26589,7 +26638,7 @@ function normalizeSubPackageStyleEntries(styles, subPackage, configService) {
   if (!service) {
     return void 0;
   }
-  const root = _optionalChain([subPackage, 'access', _490 => _490.root, 'optionalAccess', _491 => _491.trim, 'call', _492 => _492()]);
+  const root = _optionalChain([subPackage, 'access', _491 => _491.root, 'optionalAccess', _492 => _492.trim, 'call', _493 => _493()]);
   if (!root) {
     return void 0;
   }
@@ -26697,7 +26746,7 @@ function createScanService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning subpackages");
     }
-    const json = _optionalChain([scanState, 'access', _493 => _493.appEntry, 'optionalAccess', _494 => _494.json]);
+    const json = _optionalChain([scanState, 'access', _494 => _494.appEntry, 'optionalAccess', _495 => _495.json]);
     if (scanState.isDirty || subPackageMap.size === 0) {
       subPackageMap.clear();
       independentSubPackageMap.clear();
@@ -26715,15 +26764,15 @@ function createScanService(ctx) {
             subPackage,
             entries: resolveSubPackageEntries(subPackage)
           };
-          const subPackageConfig = _optionalChain([ctx, 'access', _495 => _495.configService, 'access', _496 => _496.weappViteConfig, 'optionalAccess', _497 => _497.subPackages, 'optionalAccess', _498 => _498[subPackage.root]]);
-          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _499 => _499.dependencies]);
-          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _500 => _500.inlineConfig]);
+          const subPackageConfig = _optionalChain([ctx, 'access', _496 => _496.configService, 'access', _497 => _497.weappViteConfig, 'optionalAccess', _498 => _498.subPackages, 'optionalAccess', _499 => _499[subPackage.root]]);
+          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _500 => _500.dependencies]);
+          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _501 => _501.inlineConfig]);
           meta.styleEntries = normalizeSubPackageStyleEntries(
-            _optionalChain([subPackageConfig, 'optionalAccess', _501 => _501.styles]),
+            _optionalChain([subPackageConfig, 'optionalAccess', _502 => _502.styles]),
             subPackage,
             ctx.configService
           );
-          meta.watchSharedStyles = _nullishCoalesce(_optionalChain([subPackageConfig, 'optionalAccess', _502 => _502.watchSharedStyles]), () => ( true));
+          meta.watchSharedStyles = _nullishCoalesce(_optionalChain([subPackageConfig, 'optionalAccess', _503 => _503.watchSharedStyles]), () => ( true));
           metas.push(meta);
           if (subPackage.root) {
             subPackageMap.set(subPackage.root, meta);
@@ -26779,11 +26828,11 @@ function createScanService(ctx) {
     loadSubPackages,
     isMainPackageFileName,
     get workersOptions() {
-      return _optionalChain([scanState, 'access', _503 => _503.appEntry, 'optionalAccess', _504 => _504.json, 'optionalAccess', _505 => _505.workers]);
+      return _optionalChain([scanState, 'access', _504 => _504.appEntry, 'optionalAccess', _505 => _505.json, 'optionalAccess', _506 => _506.workers]);
     },
     get workersDir() {
-      const workersOptions = _optionalChain([scanState, 'access', _506 => _506.appEntry, 'optionalAccess', _507 => _507.json, 'optionalAccess', _508 => _508.workers]);
-      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _509 => _509.path]) : workersOptions;
+      const workersOptions = _optionalChain([scanState, 'access', _507 => _507.appEntry, 'optionalAccess', _508 => _508.json, 'optionalAccess', _509 => _509.workers]);
+      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _510 => _510.path]) : workersOptions;
     },
     markDirty() {
       scanState.isDirty = true;
@@ -26830,7 +26879,7 @@ function createWatcherService(ctx) {
     },
     setRollupWatcher(watcher, root = "/") {
       const oldWatcher = rollupWatcherMap.get(root);
-      _optionalChain([oldWatcher, 'optionalAccess', _510 => _510.close, 'call', _511 => _511()]);
+      _optionalChain([oldWatcher, 'optionalAccess', _511 => _511.close, 'call', _512 => _512()]);
       rollupWatcherMap.set(root, watcher);
     },
     closeAll() {
@@ -26843,7 +26892,7 @@ function createWatcherService(ctx) {
         });
       });
       sidecarWatcherMap.clear();
-      void _optionalChain([ctx, 'access', _512 => _512.webService, 'optionalAccess', _513 => _513.close, 'call', _514 => _514(), 'access', _515 => _515.catch, 'call', _516 => _516(() => {
+      void _optionalChain([ctx, 'access', _513 => _513.webService, 'optionalAccess', _514 => _514.close, 'call', _515 => _515(), 'access', _516 => _516.catch, 'call', _517 => _517(() => {
       })]);
     },
     close(root = "/") {
@@ -26859,7 +26908,7 @@ function createWatcherService(ctx) {
         sidecarWatcherMap.delete(root);
       }
       if (rollupWatcherMap.size === 0 && sidecarWatcherMap.size === 0) {
-        void _optionalChain([ctx, 'access', _517 => _517.webService, 'optionalAccess', _518 => _518.close, 'call', _519 => _519(), 'access', _520 => _520.catch, 'call', _521 => _521(() => {
+        void _optionalChain([ctx, 'access', _518 => _518.webService, 'optionalAccess', _519 => _519.close, 'call', _520 => _520(), 'access', _521 => _521.catch, 'call', _522 => _522(() => {
         })]);
       }
     }
@@ -26872,7 +26921,7 @@ function createWatcherServicePlugin(ctx) {
     name: "weapp-runtime:watcher-service",
     closeBundle() {
       const configService = ctx.configService;
-      const isWatchMode = _optionalChain([configService, 'optionalAccess', _522 => _522.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _523 => _523.inlineConfig, 'optionalAccess', _524 => _524.build, 'optionalAccess', _525 => _525.watch]));
+      const isWatchMode = _optionalChain([configService, 'optionalAccess', _523 => _523.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _524 => _524.inlineConfig, 'optionalAccess', _525 => _525.build, 'optionalAccess', _526 => _526.watch]));
       if (!isWatchMode) {
         service.closeAll();
       }
@@ -26889,10 +26938,10 @@ function createWebService(ctx) {
   }
   let devServer;
   function isEnabled() {
-    return Boolean(_optionalChain([ctx, 'access', _526 => _526.configService, 'optionalAccess', _527 => _527.weappWebConfig, 'optionalAccess', _528 => _528.enabled]));
+    return Boolean(_optionalChain([ctx, 'access', _527 => _527.configService, 'optionalAccess', _528 => _528.weappWebConfig, 'optionalAccess', _529 => _529.enabled]));
   }
   async function startDevServer() {
-    if (!_optionalChain([ctx, 'access', _529 => _529.configService, 'optionalAccess', _530 => _530.isDev])) {
+    if (!_optionalChain([ctx, 'access', _530 => _530.configService, 'optionalAccess', _531 => _531.isDev])) {
       return void 0;
     }
     if (!isEnabled()) {
@@ -26901,7 +26950,7 @@ function createWebService(ctx) {
     if (devServer) {
       return devServer;
     }
-    const inlineConfig = _optionalChain([ctx, 'access', _531 => _531.configService, 'optionalAccess', _532 => _532.mergeWeb, 'call', _533 => _533()]);
+    const inlineConfig = _optionalChain([ctx, 'access', _532 => _532.configService, 'optionalAccess', _533 => _533.mergeWeb, 'call', _534 => _534()]);
     if (!inlineConfig) {
       return void 0;
     }
@@ -26914,7 +26963,7 @@ function createWebService(ctx) {
     if (!isEnabled()) {
       return void 0;
     }
-    const inlineConfig = _optionalChain([ctx, 'access', _534 => _534.configService, 'optionalAccess', _535 => _535.mergeWeb, 'call', _536 => _536()]);
+    const inlineConfig = _optionalChain([ctx, 'access', _535 => _535.configService, 'optionalAccess', _536 => _536.mergeWeb, 'call', _537 => _537()]);
     if (!inlineConfig) {
       return void 0;
     }
@@ -26944,7 +26993,7 @@ function createWebServicePlugin(ctx) {
   return {
     name: "weapp-runtime:web-service",
     async closeBundle() {
-      if (!_optionalChain([ctx, 'access', _537 => _537.configService, 'optionalAccess', _538 => _538.isDev])) {
+      if (!_optionalChain([ctx, 'access', _538 => _538.configService, 'optionalAccess', _539 => _539.isDev])) {
         await service.close();
       }
     }
@@ -29593,7 +29642,7 @@ function createWxmlService(ctx) {
     return set3;
   }
   function clearAll() {
-    const currentRoot = _optionalChain([ctx, 'access', _539 => _539.configService, 'optionalAccess', _540 => _540.currentSubPackageRoot]);
+    const currentRoot = _optionalChain([ctx, 'access', _540 => _540.configService, 'optionalAccess', _541 => _541.currentSubPackageRoot]);
     if (!currentRoot) {
       depsMap.clear();
       tokenMap.clear();
@@ -29652,7 +29701,7 @@ function createWxmlService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning wxml");
     }
-    const wxmlConfig = _nullishCoalesce(_optionalChain([ctx, 'access', _541 => _541.configService, 'access', _542 => _542.weappViteConfig, 'optionalAccess', _543 => _543.wxml]), () => ( _optionalChain([ctx, 'access', _544 => _544.configService, 'access', _545 => _545.weappViteConfig, 'optionalAccess', _546 => _546.enhance, 'optionalAccess', _547 => _547.wxml])));
+    const wxmlConfig = _nullishCoalesce(_optionalChain([ctx, 'access', _542 => _542.configService, 'access', _543 => _543.weappViteConfig, 'optionalAccess', _544 => _544.wxml]), () => ( _optionalChain([ctx, 'access', _545 => _545.configService, 'access', _546 => _546.weappViteConfig, 'optionalAccess', _547 => _547.enhance, 'optionalAccess', _548 => _548.wxml])));
     return scanWxml(wxml, {
       platform: ctx.configService.platform,
       ...wxmlConfig === true ? {} : wxmlConfig