weapp-vite 5.6.3 → 5.7.1

package/dist/{chunk-OQYESMEY.cjs → chunk-T4OVF4GP.cjs}

@@ -650,11 +650,6 @@ var require_eventemitter3 = _chunkA5DD7GKXcjs.__commonJS.call(void 0, {
   }
 });
 
-// src/logger.ts
-_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
-var _logger = require('@weapp-core/logger'); var _logger2 = _interopRequireDefault(_logger);
-var logger_default = _logger2.default;
-
 // src/constants.ts
 _chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
 var VERSION = "__VERSION__";
@@ -673,6 +668,13 @@ var templateExtensions = ["wxml", "html"];
 _chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
 var import_gte = _chunkA5DD7GKXcjs.__toESM.call(void 0, require_gte(), 1);
 var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+
+// src/logger.ts
+_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+var _logger = require('@weapp-core/logger'); var _logger2 = _interopRequireDefault(_logger);
+var logger_default = _logger2.default;
+
+// src/utils/version.ts
 function getRuntime() {
   if (typeof _process2.default !== "undefined" && _optionalChain([_process2.default, 'access', _2 => _2.versions, 'optionalAccess', _3 => _3.node])) {
     return {
@@ -707,55 +709,13 @@ function checkRuntime(minVersions) {
   }
 }
 
-// src/utils/weappConfig.ts
-_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
-var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
-var _pathe = require('pathe'); var _pathe2 = _interopRequireDefault(_pathe);
-var WEAPP_VITE_CONFIG_CANDIDATES = [
-  "weapp-vite.config.ts",
-  "weapp-vite.config.mts",
-  "weapp-vite.config.cts",
-  "weapp-vite.config.js",
-  "weapp-vite.config.mjs",
-  "weapp-vite.config.cjs",
-  "weapp-vite.config.json"
-];
-var WEAPP_VITE_CONFIG_SET = new Set(WEAPP_VITE_CONFIG_CANDIDATES);
-async function findWeappConfigInDirectory(directory) {
-  for (const filename of WEAPP_VITE_CONFIG_CANDIDATES) {
-    const candidatePath = _pathe2.default.resolve(directory, filename);
-    if (await _fsextra2.default.pathExists(candidatePath)) {
-      return candidatePath;
-    }
-  }
-  return void 0;
-}
-async function resolveWeappConfigFile(options) {
-  const { root, specified } = options;
-  if (specified) {
-    const resolvedSpecified = _pathe2.default.isAbsolute(specified) ? specified : _pathe2.default.resolve(root, specified);
-    const specifiedBaseName = _pathe2.default.basename(resolvedSpecified);
-    if (WEAPP_VITE_CONFIG_SET.has(specifiedBaseName)) {
-      if (await _fsextra2.default.pathExists(resolvedSpecified)) {
-        return resolvedSpecified;
-      }
-      return void 0;
-    }
-    const fromSpecifiedDirectory = await findWeappConfigInDirectory(_pathe2.default.dirname(resolvedSpecified));
-    if (fromSpecifiedDirectory) {
-      return fromSpecifiedDirectory;
-    }
-  }
-  return findWeappConfigInDirectory(root);
-}
-
 // src/utils/index.ts
 _chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
 
 // src/utils/file.ts
 _chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
-
-
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _pathe = require('pathe'); var _pathe2 = _interopRequireDefault(_pathe);
 function isJsOrTs(name) {
   if (typeof name === "string") {
     return /\.[jt]s$/.test(name);
@@ -1015,121 +975,46 @@ function regExpTest(arr, str, options) {
   return false;
 }
 
-// src/platform.ts
+// src/utils/weappConfig.ts
 _chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
 
-// src/platforms/adapters.ts
-_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
-var MINI_PROGRAM_PLATFORM_ADAPTERS = [
-  {
-    id: "weapp",
-    displayName: "WeChat Mini Program",
-    aliases: ["weapp", "wechat", "weixin", "wx"],
-    outputExtensions: {
-      js: "js",
-      json: "json",
-      wxml: "wxml",
-      wxss: "wxss",
-      wxs: "wxs"
-    }
-  },
-  {
-    id: "alipay",
-    displayName: "Alipay Mini Program",
-    aliases: ["alipay", "ali", "my"],
-    outputExtensions: {
-      js: "js",
-      json: "json",
-      wxml: "axml",
-      wxss: "acss",
-      wxs: "sjs"
-    }
-  },
-  {
-    id: "swan",
-    displayName: "Baidu Smart Program",
-    aliases: ["swan", "baidu", "bd"],
-    outputExtensions: {
-      js: "js",
-      json: "json",
-      wxml: "swan",
-      wxss: "css",
-      wxs: "sjs"
-    }
-  },
-  {
-    id: "tt",
-    displayName: "ByteDance / Douyin Mini Program",
-    aliases: ["tt", "toutiao", "bytedance", "douyin"],
-    outputExtensions: {
-      js: "js",
-      json: "json",
-      wxml: "ttml",
-      wxss: "ttss"
-    }
-  },
-  {
-    id: "jd",
-    displayName: "JD Mini Program",
-    aliases: ["jd", "jingdong"],
-    outputExtensions: {
-      js: "js",
-      json: "json",
-      wxml: "jxml",
-      wxss: "jxss",
-      wxs: "wxs"
-    }
-  },
-  {
-    id: "xhs",
-    displayName: "Xiaohongshu Mini Program",
-    aliases: ["xhs", "xiaohongshu", "little-red-book", "red"],
-    outputExtensions: {
-      js: "js",
-      json: "json",
-      wxml: "xhsml",
-      wxss: "css",
-      wxs: "wxs"
-    }
-  }
-];
 
-// src/platform.ts
-var DEFAULT_MP_PLATFORM = "weapp";
-var PLATFORM_ADAPTER_BY_ID = /* @__PURE__ */ new Map();
-var PLATFORM_ALIAS_TO_ID = /* @__PURE__ */ new Map();
-for (const adapter of MINI_PROGRAM_PLATFORM_ADAPTERS) {
-  PLATFORM_ADAPTER_BY_ID.set(adapter.id, adapter);
-  for (const alias of adapter.aliases) {
-    const normalized = alias.trim().toLowerCase();
-    if (!normalized) {
-      continue;
+var WEAPP_VITE_CONFIG_CANDIDATES = [
+  "weapp-vite.config.ts",
+  "weapp-vite.config.mts",
+  "weapp-vite.config.cts",
+  "weapp-vite.config.js",
+  "weapp-vite.config.mjs",
+  "weapp-vite.config.cjs",
+  "weapp-vite.config.json"
+];
+var WEAPP_VITE_CONFIG_SET = new Set(WEAPP_VITE_CONFIG_CANDIDATES);
+async function findWeappConfigInDirectory(directory) {
+  for (const filename of WEAPP_VITE_CONFIG_CANDIDATES) {
+    const candidatePath = _pathe2.default.resolve(directory, filename);
+    if (await _fsextra2.default.pathExists(candidatePath)) {
+      return candidatePath;
     }
-    PLATFORM_ALIAS_TO_ID.set(normalized, adapter.id);
-  }
-  if (!PLATFORM_ALIAS_TO_ID.has(adapter.id)) {
-    PLATFORM_ALIAS_TO_ID.set(adapter.id, adapter.id);
-  }
-}
-var MINI_PLATFORM_ALIASES = Object.freeze(
-  Object.fromEntries(PLATFORM_ALIAS_TO_ID.entries())
-);
-function normalizeMiniPlatform(input) {
-  return input ? input.trim().toLowerCase() : void 0;
-}
-function resolveMiniPlatform(input) {
-  const normalized = normalizeMiniPlatform(input);
-  if (!normalized) {
-    return void 0;
   }
-  return PLATFORM_ALIAS_TO_ID.get(normalized);
+  return void 0;
 }
-function getMiniProgramPlatformAdapter(platform) {
-  const adapter = PLATFORM_ADAPTER_BY_ID.get(platform);
-  if (!adapter) {
-    throw new Error(`Unsupported mini program platform "${platform}".`);
+async function resolveWeappConfigFile(options) {
+  const { root, specified } = options;
+  if (specified) {
+    const resolvedSpecified = _pathe2.default.isAbsolute(specified) ? specified : _pathe2.default.resolve(root, specified);
+    const specifiedBaseName = _pathe2.default.basename(resolvedSpecified);
+    if (WEAPP_VITE_CONFIG_SET.has(specifiedBaseName)) {
+      if (await _fsextra2.default.pathExists(resolvedSpecified)) {
+        return resolvedSpecified;
+      }
+      return void 0;
+    }
+    const fromSpecifiedDirectory = await findWeappConfigInDirectory(_pathe2.default.dirname(resolvedSpecified));
+    if (fromSpecifiedDirectory) {
+      return fromSpecifiedDirectory;
+    }
   }
-  return adapter;
+  return findWeappConfigInDirectory(root);
 }
 
 // src/context/getInstance.ts
@@ -11895,57 +11780,322 @@ rimraf.rimraf = rimraf;
 // src/runtime/buildPlugin.ts
 var _vite = require('vite');
 
-// src/runtime/advancedChunks.ts
-_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
-
-// src/runtime/chunkStrategy.ts
+// src/runtime/independentError.ts
 _chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
-
-var SHARED_CHUNK_VIRTUAL_PREFIX = "weapp_shared_virtual";
-var SUB_PACKAGE_SHARED_DIR = "weapp-shared";
-var DEFAULT_SHARED_CHUNK_STRATEGY = "duplicate";
-function resolveSharedChunkName(options) {
-  const {
-    id,
-    ctx,
-    relativeAbsoluteSrcRoot,
-    subPackageRoots,
-    strategy
-  } = options;
-  const moduleInfo = ctx.getModuleInfo(id);
-  if (!_optionalChain([moduleInfo, 'optionalAccess', _224 => _224.importers]) || moduleInfo.importers.length <= 1) {
-    return void 0;
+var ANSI_ESCAPE_PATTERN = /\u001B\[[0-9;]*m/g;
+function stripAnsi(value) {
+  return value.replace(ANSI_ESCAPE_PATTERN, "");
+}
+function isErrorInstance(value) {
+  return value instanceof Error;
+}
+function formatSummary(payload) {
+  const parts = [];
+  const code = payload.code;
+  if (typeof code === "string" && code.trim()) {
+    parts.push(`code: ${code.trim()}`);
   }
-  const summary = summarizeImportPrefixes({
-    importers: moduleInfo.importers,
-    relativeAbsoluteSrcRoot,
-    subPackageRoots: Array.from(subPackageRoots)
-  });
-  const keys = Object.keys(summary);
-  if (keys.length === 0) {
-    return void 0;
+  const plugin = payload.plugin;
+  if (typeof plugin === "string" && plugin.trim()) {
+    parts.push(`plugin: ${plugin.trim()}`);
   }
-  if (keys.length === 1) {
-    const prefix = keys[0];
-    return prefix ? _pathe.posix.join(prefix, "common") : "common";
+  const id = payload.id;
+  if (typeof id === "string" && id.trim()) {
+    parts.push(`id: ${id.trim()}`);
   }
-  const hasMainImporter = keys.includes("");
-  if (strategy === "duplicate" && !hasMainImporter) {
-    const combination = keys.filter(Boolean).sort().join("+");
-    const combinationSegment = combination ? `${combination}/` : "";
-    return `${SHARED_CHUNK_VIRTUAL_PREFIX}/${combinationSegment}common`;
+  if (!parts.length) {
+    return "";
   }
-  return "common";
+  return ` (${parts.join(", ")})`;
 }
-function summarizeImportPrefixes(options) {
-  const { importers, relativeAbsoluteSrcRoot, subPackageRoots } = options;
-  const summary = {};
-  for (const importer of importers) {
-    const relPath = relativeAbsoluteSrcRoot(importer);
-    const prefix = resolveSubPackagePrefix(relPath, subPackageRoots);
-    summary[prefix] = (summary[prefix] || 0) + 1;
+function collectDetails(payload) {
+  const details = [];
+  const frame = payload.frame;
+  if (typeof frame === "string" && frame.trim()) {
+    details.push(frame.trim());
+  }
+  const stack = payload.stack;
+  if (typeof stack === "string" && stack.trim()) {
+    details.push(stack.trim());
+  }
+  return details;
+}
+function extractMessage(value, seen) {
+  if (!value || seen.has(value)) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const trimmed = stripAnsi(value).trim();
+    return trimmed || void 0;
+  }
+  if (isErrorInstance(value)) {
+    const trimmed = stripAnsi(_nullishCoalesce(value.message, () => ( ""))).trim();
+    if (trimmed) {
+      return trimmed;
+    }
+    if (value.cause) {
+      return extractMessage(value.cause, seen);
+    }
+    return void 0;
+  }
+  if (typeof value === "object") {
+    const record = value;
+    seen.add(record);
+    const directMessage = extractMessage(record.message, seen);
+    if (directMessage) {
+      return directMessage;
+    }
+    const nestedKeys = ["reason", "detail", "details", "error", "field0", "field1", "cause"];
+    for (const key of nestedKeys) {
+      if (key in record) {
+        const nestedMessage = extractMessage(record[key], seen);
+        if (nestedMessage) {
+          return nestedMessage;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function createIndependentBuildError(root, cause) {
+  const fallback = `Independent bundle for ${root} failed`;
+  if (isErrorInstance(cause)) {
+    if (!cause.message || cause.message.trim() === "") {
+      return new Error(fallback, { cause });
+    }
+    return cause;
+  }
+  if (!cause) {
+    return new Error(fallback);
+  }
+  if (typeof cause === "string") {
+    const trimmed = stripAnsi(cause).trim();
+    if (!trimmed) {
+      return new Error(fallback, { cause });
+    }
+    return new Error(trimmed, { cause });
+  }
+  if (typeof cause === "object") {
+    const payload = cause;
+    const seen = /* @__PURE__ */ new Set();
+    const extracted = extractMessage(payload, seen);
+    const summary = formatSummary(payload);
+    const detailLines = collectDetails(payload);
+    if (extracted) {
+      let composedMessage = extracted;
+      if (summary) {
+        composedMessage += summary;
+      }
+      if (detailLines.length) {
+        composedMessage += `
+${detailLines.join("\n")}`;
+      }
+      return new Error(composedMessage, { cause });
+    }
+    if (summary || detailLines.length) {
+      const composed = detailLines.length ? `${fallback}${summary}
+${detailLines.join("\n")}` : `${fallback}${summary}`;
+      if (composed.trim()) {
+        return new Error(composed, { cause });
+      }
+    }
+  }
+  try {
+    const serialized = JSON.stringify(cause);
+    if (serialized && serialized !== "{}") {
+      return new Error(`${fallback}: ${serialized}`, { cause });
+    }
+  } catch (e13) {
+  }
+  return new Error(fallback, { cause });
+}
+
+// src/runtime/sharedBuildConfig.ts
+_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+
+
+// src/runtime/advancedChunks.ts
+_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+
+// src/runtime/chunkStrategy.ts
+_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+var _buffer = require('buffer');
+
+var SHARED_CHUNK_VIRTUAL_PREFIX = "weapp_shared_virtual";
+var SUB_PACKAGE_SHARED_DIR = "weapp-shared";
+var DEFAULT_SHARED_CHUNK_STRATEGY = "duplicate";
+var sharedChunkDiagnostics = /* @__PURE__ */ new Map();
+function resolveSharedChunkName(options) {
+  const {
+    id,
+    ctx,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots,
+    strategy,
+    forceDuplicateTester
+  } = options;
+  const moduleInfo = ctx.getModuleInfo(id);
+  if (!_optionalChain([moduleInfo, 'optionalAccess', _224 => _224.importers]) || moduleInfo.importers.length <= 1) {
+    return void 0;
   }
-  return summary;
+  const { summary, ignoredMainImporters } = summarizeImportPrefixes({
+    ctx,
+    importers: moduleInfo.importers,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots: Array.from(subPackageRoots),
+    forceDuplicateTester
+  });
+  const keys = Object.keys(summary);
+  if (keys.length === 0) {
+    return void 0;
+  }
+  if (keys.length === 1) {
+    const prefix = keys[0];
+    return prefix ? _pathe.posix.join(prefix, "common") : "common";
+  }
+  const hasMainImporter = keys.includes("");
+  if (strategy === "duplicate" && !hasMainImporter) {
+    const combination = keys.filter(Boolean).sort().join("+");
+    const combinationSegment = combination ? `${combination}/` : "";
+    const sharedName = `${SHARED_CHUNK_VIRTUAL_PREFIX}/${combinationSegment}common`;
+    if (ignoredMainImporters.length) {
+      sharedChunkDiagnostics.set(sharedName, {
+        ignoredMainImporters: Array.from(new Set(ignoredMainImporters))
+      });
+      sharedChunkDiagnostics.set(`${sharedName}.js`, {
+        ignoredMainImporters: Array.from(new Set(ignoredMainImporters))
+      });
+    }
+    return sharedName;
+  }
+  return "common";
+}
+function summarizeImportPrefixes(options) {
+  const {
+    ctx,
+    importers,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots,
+    forceDuplicateTester
+  } = options;
+  const summary = {};
+  const ignoredImporters = /* @__PURE__ */ new Set();
+  const state = {
+    cache: /* @__PURE__ */ new Map(),
+    stack: /* @__PURE__ */ new Set()
+  };
+  for (const importer of importers) {
+    const { prefixes, ignored } = collectEffectivePrefixes(importer, {
+      ctx,
+      relativeAbsoluteSrcRoot,
+      subPackageRoots,
+      forceDuplicateTester
+    }, state);
+    for (const prefix of prefixes) {
+      summary[prefix] = (summary[prefix] || 0) + 1;
+    }
+    for (const entry of ignored) {
+      ignoredImporters.add(entry);
+    }
+  }
+  return {
+    summary,
+    ignoredMainImporters: Array.from(ignoredImporters)
+  };
+}
+function collectEffectivePrefixes(importer, options, state) {
+  const cached = state.cache.get(importer);
+  if (cached) {
+    return {
+      prefixes: [...cached.prefixes],
+      hasRealMain: cached.hasRealMain,
+      ignored: [...cached.ignored]
+    };
+  }
+  if (state.stack.has(importer)) {
+    return {
+      prefixes: [""],
+      hasRealMain: true,
+      ignored: []
+    };
+  }
+  state.stack.add(importer);
+  const {
+    ctx,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots,
+    forceDuplicateTester
+  } = options;
+  const relativeId = relativeAbsoluteSrcRoot(importer);
+  const subPackagePrefix = resolveSubPackagePrefix(relativeId, subPackageRoots);
+  if (subPackagePrefix) {
+    const result2 = {
+      prefixes: [subPackagePrefix],
+      hasRealMain: false,
+      ignored: []
+    };
+    state.cache.set(importer, result2);
+    state.stack.delete(importer);
+    return {
+      prefixes: [...result2.prefixes],
+      hasRealMain: result2.hasRealMain,
+      ignored: []
+    };
+  }
+  const moduleInfo = ctx.getModuleInfo(importer);
+  const importerParents = _nullishCoalesce(_optionalChain([moduleInfo, 'optionalAccess', _225 => _225.importers]), () => ( []));
+  const forcedDuplicate = _nullishCoalesce(_optionalChain([forceDuplicateTester, 'optionalCall', _226 => _226(relativeId, importer)]), () => ( false));
+  if (!importerParents.length) {
+    const result2 = forcedDuplicate ? {
+      prefixes: [],
+      hasRealMain: false,
+      ignored: [relativeId]
+    } : {
+      prefixes: [""],
+      hasRealMain: true,
+      ignored: []
+    };
+    state.cache.set(importer, result2);
+    state.stack.delete(importer);
+    return {
+      prefixes: [...result2.prefixes],
+      hasRealMain: result2.hasRealMain,
+      ignored: [...result2.ignored]
+    };
+  }
+  const aggregatedPrefixes = /* @__PURE__ */ new Set();
+  let hasRealMain = false;
+  const aggregatedIgnored = [];
+  for (const parent of importerParents) {
+    const collectorResult = collectEffectivePrefixes(parent, options, state);
+    for (const prefix of collectorResult.prefixes) {
+      aggregatedPrefixes.add(prefix);
+    }
+    if (collectorResult.hasRealMain) {
+      hasRealMain = true;
+    }
+    if (collectorResult.ignored.length) {
+      aggregatedIgnored.push(...collectorResult.ignored);
+    }
+  }
+  if (!aggregatedPrefixes.size) {
+    aggregatedPrefixes.add("");
+    hasRealMain = true;
+  }
+  const shouldIgnoreAsMain = !aggregatedPrefixes.has("") && importerParents.length > 0;
+  const ignored = shouldIgnoreAsMain || forcedDuplicate && !aggregatedPrefixes.has("") ? [relativeId] : [];
+  const result = {
+    prefixes: Array.from(aggregatedPrefixes),
+    hasRealMain,
+    ignored: Array.from(/* @__PURE__ */ new Set([...aggregatedIgnored, ...ignored]))
+  };
+  state.cache.set(importer, result);
+  state.stack.delete(importer);
+  return {
+    prefixes: [...result.prefixes],
+    hasRealMain: result.hasRealMain,
+    ignored: [...result.ignored]
+  };
 }
 function resolveSubPackagePrefix(fileName, subPackageRoots) {
   for (const root of subPackageRoots) {
@@ -12001,13 +12151,14 @@ function applySharedChunkStrategy(bundle, options) {
       }
     }
     if (hasMainImporter || importerMap.size === 0) {
+      consumeSharedChunkDiagnostics(originalSharedFileName);
       let finalFileName = chunk.fileName;
       if (fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`)) {
         const newFileName = fileName.slice(SHARED_CHUNK_VIRTUAL_PREFIX.length + 1);
         chunk.fileName = newFileName;
         finalFileName = newFileName;
       }
-      _optionalChain([options, 'access', _225 => _225.onFallback, 'optionalCall', _226 => _226({
+      _optionalChain([options, 'access', _227 => _227.onFallback, 'optionalCall', _228 => _228({
         sharedFileName: originalSharedFileName,
         finalFileName,
         reason: hasMainImporter ? "main-package" : "no-subpackage",
@@ -12017,6 +12168,7 @@ function applySharedChunkStrategy(bundle, options) {
     }
     const importerToChunk = /* @__PURE__ */ new Map();
     const duplicates = [];
+    const diagnostics = consumeSharedChunkDiagnostics(originalSharedFileName);
     for (const { newFileName, importers: importerFiles } of importerMap.values()) {
       this.emitFile({
         type: "asset",
@@ -12039,32 +12191,72 @@ function applySharedChunkStrategy(bundle, options) {
       });
     }
     updateImporters(bundle, importerToChunk, fileName);
-    chunk.code = "// duplicated into sub-packages via weapp-vite chunk strategy\n";
-    chunk.map = null;
-    chunk.sourcemapFileName = null;
-    chunk.imports = [];
-    chunk.dynamicImports = [];
-    chunk.exports = [];
-    chunk.moduleIds = [];
-    chunk.modules = {};
-    _optionalChain([options, 'access', _227 => _227.onDuplicate, 'optionalCall', _228 => _228({
+    delete bundle[fileName];
+    const candidateMapKeys = /* @__PURE__ */ new Set();
+    candidateMapKeys.add(`${fileName}.map`);
+    if (typeof chunk.sourcemapFileName === "string" && chunk.sourcemapFileName) {
+      candidateMapKeys.add(chunk.sourcemapFileName);
+    }
+    for (const mapKey of candidateMapKeys) {
+      if (mapKey && bundle[mapKey]) {
+        delete bundle[mapKey];
+      }
+    }
+    const chunkBytes = typeof originalCode === "string" ? _buffer.Buffer.byteLength(originalCode, "utf8") : void 0;
+    const redundantBytes = typeof chunkBytes === "number" ? chunkBytes * Math.max(duplicates.length - 1, 0) : void 0;
+    _optionalChain([options, 'access', _229 => _229.onDuplicate, 'optionalCall', _230 => _230({
       sharedFileName: originalSharedFileName,
-      duplicates
+      duplicates,
+      ignoredMainImporters: _optionalChain([diagnostics, 'optionalAccess', _231 => _231.ignoredMainImporters]),
+      chunkBytes,
+      redundantBytes
     })]);
   }
 }
+function consumeSharedChunkDiagnostics(fileName) {
+  const direct = sharedChunkDiagnostics.get(fileName);
+  if (direct) {
+    sharedChunkDiagnostics.delete(fileName);
+    return direct;
+  }
+  const withoutExt = fileName.replace(/\.[^./\\]+$/, "");
+  const fallback = sharedChunkDiagnostics.get(withoutExt);
+  if (fallback) {
+    sharedChunkDiagnostics.delete(withoutExt);
+    return fallback;
+  }
+  return void 0;
+}
 function isSharedVirtualChunk(fileName, output) {
-  return _optionalChain([output, 'optionalAccess', _229 => _229.type]) === "chunk" && fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`);
+  return _optionalChain([output, 'optionalAccess', _232 => _232.type]) === "chunk" && fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`);
 }
 function findChunkImporters(bundle, target) {
   const importers = /* @__PURE__ */ new Set();
   for (const [fileName, output] of Object.entries(bundle)) {
-    if (_optionalChain([output, 'optionalAccess', _230 => _230.type]) !== "chunk") {
+    if (_optionalChain([output, 'optionalAccess', _233 => _233.type]) !== "chunk") {
       continue;
     }
     const chunk = output;
     if (chunk.imports.includes(target) || chunk.dynamicImports.includes(target)) {
       importers.add(fileName);
+      continue;
+    }
+    const metadata = chunk.viteMetadata;
+    if (metadata) {
+      const importedChunks = metadata.importedChunks;
+      if (hasInCollection(importedChunks, target)) {
+        importers.add(fileName);
+        continue;
+      }
+      const importedScripts = _nullishCoalesce(metadata.importedScripts, () => ( metadata.importedScriptsByUrl));
+      if (hasInCollection(importedScripts, target)) {
+        importers.add(fileName);
+        continue;
+      }
+    }
+    const potentialImport = createRelativeImport(fileName, target);
+    if (potentialImport && containsImportSpecifier(_nullishCoalesce(chunk.code, () => ( "")), potentialImport)) {
+      importers.add(fileName);
     }
   }
   return Array.from(importers);
@@ -12092,11 +12284,35 @@ function updateImporters(bundle, importerToChunk, originalFileName) {
     const importerChunk = importer;
     const originalImportPath = createRelativeImport(importerFile, originalFileName);
     const newImportPath = createRelativeImport(importerFile, newChunkFile);
+    let codeUpdated = false;
     if (originalImportPath !== newImportPath) {
-      importerChunk.code = replaceAll(importerChunk.code, originalImportPath, newImportPath);
+      const updated = replaceAll(importerChunk.code, originalImportPath, newImportPath);
+      if (updated !== importerChunk.code) {
+        importerChunk.code = updated;
+        codeUpdated = true;
+      }
+    }
+    importerChunk.imports = replaceInArray(importerChunk.imports, originalFileName, newChunkFile, codeUpdated);
+    importerChunk.dynamicImports = replaceInArray(importerChunk.dynamicImports, originalFileName, newChunkFile, codeUpdated);
+    const implicitlyLoadedBefore = importerChunk.implicitlyLoadedBefore;
+    if (Array.isArray(implicitlyLoadedBefore)) {
+      importerChunk.implicitlyLoadedBefore = replaceInArray(
+        implicitlyLoadedBefore,
+        originalFileName,
+        newChunkFile,
+        codeUpdated
+      );
     }
-    importerChunk.imports = replaceInArray(importerChunk.imports, originalFileName, newChunkFile);
-    importerChunk.dynamicImports = replaceInArray(importerChunk.dynamicImports, originalFileName, newChunkFile);
+    const referencedFiles = importerChunk.referencedFiles;
+    if (Array.isArray(referencedFiles)) {
+      importerChunk.referencedFiles = replaceInArray(
+        referencedFiles,
+        originalFileName,
+        newChunkFile,
+        codeUpdated
+      );
+    }
+    updateViteMetadata(importerChunk, originalFileName, newChunkFile, codeUpdated);
   }
 }
 function replaceAll(source, searchValue, replaceValue) {
@@ -12115,185 +12331,183 @@ function replaceAll(source, searchValue, replaceValue) {
   }
   return source;
 }
-function replaceInArray(list, searchValue, replaceValue) {
-  return list.map((value) => {
-    return value === searchValue ? replaceValue : value;
-  });
-}
-function createRelativeImport(fromFile, toFile) {
-  const relative3 = _pathe.posix.relative(_pathe.posix.dirname(fromFile), toFile);
-  if (!relative3 || relative3.startsWith(".")) {
-    return relative3 || "./";
-  }
-  return `./${relative3}`;
-}
-
-// src/runtime/advancedChunks.ts
-function testByReg2DExpList(reg2DExpList) {
-  return (id) => reg2DExpList.some((regExpList) => regExpList.some((regExp) => {
-    regExp.lastIndex = 0;
-    return regExp.test(id);
-  }));
-}
-function createAdvancedChunkNameResolver(options) {
-  const {
-    relativeAbsoluteSrcRoot,
-    getSubPackageRoots,
-    strategy,
-    vendorsMatchers
-  } = options;
-  const isVendor = testByReg2DExpList(vendorsMatchers);
-  return (id, ctx) => {
-    const subPackageRoots = Array.from(getSubPackageRoots());
-    const sharedName = resolveSharedChunkName({
-      id,
-      ctx,
-      relativeAbsoluteSrcRoot,
-      subPackageRoots,
-      strategy
-    });
-    if (!isVendor(id)) {
-      return sharedName;
-    }
-    if (strategy === "hoist") {
-      return "vendors";
-    }
-    return sharedName;
-  };
-}
-
-// src/runtime/independentError.ts
-_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
-var ANSI_ESCAPE_PATTERN = /\u001B\[[0-9;]*m/g;
-function stripAnsi(value) {
-  return value.replace(ANSI_ESCAPE_PATTERN, "");
-}
-function isErrorInstance(value) {
-  return value instanceof Error;
-}
-function formatSummary(payload) {
-  const parts = [];
-  const code = payload.code;
-  if (typeof code === "string" && code.trim()) {
-    parts.push(`code: ${code.trim()}`);
-  }
-  const plugin = payload.plugin;
-  if (typeof plugin === "string" && plugin.trim()) {
-    parts.push(`plugin: ${plugin.trim()}`);
-  }
-  const id = payload.id;
-  if (typeof id === "string" && id.trim()) {
-    parts.push(`id: ${id.trim()}`);
-  }
-  if (!parts.length) {
-    return "";
+function containsImportSpecifier(source, specifier) {
+  if (!specifier) {
+    return false;
   }
-  return ` (${parts.join(", ")})`;
-}
-function collectDetails(payload) {
-  const details = [];
-  const frame = payload.frame;
-  if (typeof frame === "string" && frame.trim()) {
-    details.push(frame.trim());
+  if (source.includes(specifier)) {
+    return true;
   }
-  const stack = payload.stack;
-  if (typeof stack === "string" && stack.trim()) {
-    details.push(stack.trim());
+  if (specifier.startsWith("./")) {
+    const trimmed = specifier.slice(2);
+    if (trimmed && source.includes(trimmed)) {
+      return true;
+    }
   }
-  return details;
+  return false;
 }
-function extractMessage(value, seen) {
-  if (!value || seen.has(value)) {
-    return void 0;
+function hasInCollection(collection, value) {
+  if (!collection || !value) {
+    return false;
   }
-  if (typeof value === "string") {
-    const trimmed = stripAnsi(value).trim();
-    return trimmed || void 0;
+  if (collection instanceof Set) {
+    return collection.has(value);
   }
-  if (isErrorInstance(value)) {
-    const trimmed = stripAnsi(_nullishCoalesce(value.message, () => ( ""))).trim();
-    if (trimmed) {
-      return trimmed;
-    }
-    if (value.cause) {
-      return extractMessage(value.cause, seen);
-    }
-    return void 0;
+  if (Array.isArray(collection)) {
+    return collection.includes(value);
   }
-  if (typeof value === "object") {
-    const record = value;
-    seen.add(record);
-    const directMessage = extractMessage(record.message, seen);
-    if (directMessage) {
-      return directMessage;
-    }
-    const nestedKeys = ["reason", "detail", "details", "error", "field0", "field1", "cause"];
-    for (const key of nestedKeys) {
-      if (key in record) {
-        const nestedMessage = extractMessage(record[key], seen);
-        if (nestedMessage) {
-          return nestedMessage;
-        }
-      }
-    }
+  if (collection instanceof Map) {
+    return collection.has(value);
   }
-  return void 0;
+  return false;
 }
-function createIndependentBuildError(root, cause) {
-  const fallback = `Independent bundle for ${root} failed`;
-  if (isErrorInstance(cause)) {
-    if (!cause.message || cause.message.trim() === "") {
-      return new Error(fallback, { cause });
+function replaceInArray(list, searchValue, replaceValue, shouldInsert) {
+  const values = Array.isArray(list) ? [...list] : [];
+  let replaced = false;
+  for (let index = 0; index < values.length; index++) {
+    const current2 = values[index];
+    if (current2 === searchValue) {
+      values[index] = replaceValue;
+      replaced = true;
     }
-    return cause;
   }
-  if (!cause) {
-    return new Error(fallback);
+  if ((replaced || shouldInsert) && replaceValue && !values.includes(replaceValue)) {
+    values.push(replaceValue);
   }
-  if (typeof cause === "string") {
-    const trimmed = stripAnsi(cause).trim();
-    if (!trimmed) {
-      return new Error(fallback, { cause });
-    }
-    return new Error(trimmed, { cause });
+  return values;
+}
+function updateViteMetadata(importerChunk, originalFileName, newChunkFile, shouldInsert) {
+  const metadata = importerChunk.viteMetadata;
+  if (!metadata || typeof metadata !== "object") {
+    return;
   }
-  if (typeof cause === "object") {
-    const payload = cause;
-    const seen = /* @__PURE__ */ new Set();
-    const extracted = extractMessage(payload, seen);
-    const summary = formatSummary(payload);
-    const detailLines = collectDetails(payload);
-    if (extracted) {
-      let composedMessage = extracted;
-      if (summary) {
-        composedMessage += summary;
+  const candidateKeys = ["importedChunks", "importedScripts"];
+  for (const key of candidateKeys) {
+    const collection = metadata[key];
+    if (collection instanceof Set) {
+      const hadOriginal = collection.delete(originalFileName);
+      if (hadOriginal || shouldInsert) {
+        collection.add(newChunkFile);
       }
-      if (detailLines.length) {
-        composedMessage += `
-${detailLines.join("\n")}`;
+    } else if (Array.isArray(collection)) {
+      metadata[key] = replaceInArray(collection, originalFileName, newChunkFile, shouldInsert);
+    } else if (collection instanceof Map) {
+      if (collection.has(originalFileName)) {
+        const originalValue = collection.get(originalFileName);
+        collection.delete(originalFileName);
+        collection.set(newChunkFile, originalValue);
       }
-      return new Error(composedMessage, { cause });
     }
-    if (summary || detailLines.length) {
-      const composed = detailLines.length ? `${fallback}${summary}
-${detailLines.join("\n")}` : `${fallback}${summary}`;
-      if (composed.trim()) {
-        return new Error(composed, { cause });
-      }
+  }
+}
+function createRelativeImport(fromFile, toFile) {
+  const relative3 = _pathe.posix.relative(_pathe.posix.dirname(fromFile), toFile);
+  if (!relative3 || relative3.startsWith(".")) {
+    return relative3 || "./";
+  }
+  return `./${relative3}`;
+}
+
+// src/runtime/advancedChunks.ts
+function testByReg2DExpList(reg2DExpList) {
+  return (id) => reg2DExpList.some((regExpList) => regExpList.some((regExp) => {
+    regExp.lastIndex = 0;
+    return regExp.test(id);
+  }));
+}
+function createAdvancedChunkNameResolver(options) {
+  const {
+    relativeAbsoluteSrcRoot,
+    getSubPackageRoots,
+    strategy,
+    vendorsMatchers,
+    forceDuplicateTester
+  } = options;
+  const isVendor = testByReg2DExpList(vendorsMatchers);
+  return (id, ctx) => {
+    const subPackageRoots = Array.from(getSubPackageRoots());
+    const sharedName = resolveSharedChunkName({
+      id,
+      ctx,
+      relativeAbsoluteSrcRoot,
+      subPackageRoots,
+      strategy,
+      forceDuplicateTester
+    });
+    if (!isVendor(id)) {
+      return sharedName;
+    }
+    if (strategy === "hoist") {
+      return "vendors";
     }
+    return sharedName;
+  };
+}
+
+// src/runtime/sharedBuildConfig.ts
+var REG_NODE_MODULES_DIR = /[\\/]node_modules[\\/]/gi;
+var REG_COMMONJS_HELPERS = /commonjsHelpers\.js$/;
+function createForceDuplicateTester(patterns) {
+  if (!patterns || patterns.length === 0) {
+    return void 0;
   }
-  try {
-    const serialized = JSON.stringify(cause);
-    if (serialized && serialized !== "{}") {
-      return new Error(`${fallback}: ${serialized}`, { cause });
+  const matchers = patterns.map((pattern) => {
+    if (typeof pattern === "string") {
+      const matcher = _picomatch2.default.call(void 0, pattern, { dot: true });
+      return (value) => matcher(value);
     }
-  } catch (e13) {
+    if (isRegexp(pattern)) {
+      return (value) => {
+        pattern.lastIndex = 0;
+        return pattern.test(value);
+      };
+    }
+    return void 0;
+  }).filter((matcher) => typeof matcher === "function");
+  if (!matchers.length) {
+    return void 0;
   }
-  return new Error(fallback, { cause });
+  return (relativeId, absoluteId) => {
+    for (const matcher of matchers) {
+      if (matcher(relativeId) || matcher(absoluteId)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function createSharedBuildConfig(configService, scanService) {
+  const nodeModulesDeps = [REG_NODE_MODULES_DIR];
+  const commonjsHelpersDeps = [REG_COMMONJS_HELPERS];
+  const sharedStrategy = _nullishCoalesce(_optionalChain([configService, 'access', _234 => _234.weappViteConfig, 'optionalAccess', _235 => _235.chunks, 'optionalAccess', _236 => _236.sharedStrategy]), () => ( DEFAULT_SHARED_CHUNK_STRATEGY));
+  const forceDuplicatePatterns = _optionalChain([configService, 'access', _237 => _237.weappViteConfig, 'optionalAccess', _238 => _238.chunks, 'optionalAccess', _239 => _239.forceDuplicatePatterns]);
+  const forceDuplicateTester = createForceDuplicateTester(forceDuplicatePatterns);
+  const resolveAdvancedChunkName = createAdvancedChunkNameResolver({
+    vendorsMatchers: [nodeModulesDeps, commonjsHelpersDeps],
+    relativeAbsoluteSrcRoot: configService.relativeAbsoluteSrcRoot,
+    getSubPackageRoots: () => scanService.subPackageMap.keys(),
+    strategy: sharedStrategy,
+    forceDuplicateTester
+  });
+  return {
+    build: {
+      rolldownOptions: {
+        output: {
+          advancedChunks: {
+            groups: [
+              {
+                name: (id, ctx) => resolveAdvancedChunkName(id, ctx)
+              }
+            ]
+          },
+          chunkFileNames: "[name].js"
+        }
+      }
+    }
+  };
 }
 
 // src/runtime/buildPlugin.ts
-var REG_NODE_MODULES_DIR = /[\\/]node_modules[\\/]/gi;
 function createBuildService(ctx) {
   function assertRuntimeServices(target) {
     if (!target.configService || !target.watcherService || !target.npmService || !target.scanService) {
@@ -12360,7 +12574,7 @@ function createBuildService(ctx) {
   function checkWorkersOptions() {
     const workersDir = scanService.workersDir;
     const hasWorkersDir = Boolean(workersDir);
-    if (hasWorkersDir && _optionalChain([configService, 'access', _231 => _231.weappViteConfig, 'optionalAccess', _232 => _232.worker, 'optionalAccess', _233 => _233.entry]) === void 0) {
+    if (hasWorkersDir && _optionalChain([configService, 'access', _240 => _240.weappViteConfig, 'optionalAccess', _241 => _241.worker, 'optionalAccess', _242 => _242.entry]) === void 0) {
       logger_default.error("\u68C0\u6D4B\u5230\u5DF2\u7ECF\u5F00\u542F\u4E86 `worker`\uFF0C\u8BF7\u5728 `vite.config.ts` \u4E2D\u8BBE\u7F6E `weapp.worker.entry` \u8DEF\u5F84");
       logger_default.error("\u6BD4\u5982\u5F15\u5165\u7684 `worker` \u8DEF\u5F84\u4E3A `workers/index`, \u6B64\u65F6 `weapp.worker.entry` \u8BBE\u7F6E\u4E3A `[index]` ");
       throw new Error("\u8BF7\u5728 `vite.config.ts` \u4E2D\u8BBE\u7F6E `weapp.worker.entry` \u8DEF\u5F84");
@@ -12381,40 +12595,16 @@ function createBuildService(ctx) {
       configService.mergeWorkers()
     );
   }
-  function sharedBuildConfig() {
-    const nodeModulesDeps = [REG_NODE_MODULES_DIR];
-    const commonjsHelpersDeps = [/commonjsHelpers\.js$/];
-    const sharedStrategy = _nullishCoalesce(_optionalChain([configService, 'access', _234 => _234.weappViteConfig, 'optionalAccess', _235 => _235.chunks, 'optionalAccess', _236 => _236.sharedStrategy]), () => ( DEFAULT_SHARED_CHUNK_STRATEGY));
-    const resolveAdvancedChunkName = createAdvancedChunkNameResolver({
-      vendorsMatchers: [nodeModulesDeps, commonjsHelpersDeps],
-      relativeAbsoluteSrcRoot: configService.relativeAbsoluteSrcRoot,
-      getSubPackageRoots: () => scanService.subPackageMap.keys(),
-      strategy: sharedStrategy
-    });
-    return {
-      build: {
-        rolldownOptions: {
-          output: {
-            advancedChunks: {
-              groups: [
-                {
-                  name: (id, ctxPlugin) => resolveAdvancedChunkName(id, ctxPlugin)
-                }
-              ]
-            },
-            chunkFileNames: "[name].js"
-          }
-        }
-      }
-    };
-  }
   async function runDev() {
     if (_process2.default.env.NODE_ENV === void 0) {
       _process2.default.env.NODE_ENV = "development";
     }
-    _optionalChain([debug, 'optionalCall', _237 => _237("dev build watcher start")]);
+    _optionalChain([debug, 'optionalCall', _243 => _243("dev build watcher start")]);
     const { hasWorkersDir, workersDir } = checkWorkersOptions();
-    const buildOptions = configService.merge(void 0, sharedBuildConfig());
+    const buildOptions = configService.merge(
+      void 0,
+      createSharedBuildConfig(configService, scanService)
+    );
     const watcherPromise = _vite.build.call(void 0, 
       buildOptions
     );
@@ -12476,8 +12666,8 @@ function createBuildService(ctx) {
         });
       }
     }
-    _optionalChain([debug, 'optionalCall', _238 => _238("dev build watcher end")]);
-    _optionalChain([debug, 'optionalCall', _239 => _239("dev watcher listen start")]);
+    _optionalChain([debug, 'optionalCall', _244 => _244("dev build watcher end")]);
+    _optionalChain([debug, 'optionalCall', _245 => _245("dev watcher listen start")]);
     let startTime;
     let resolveWatcher;
     let rejectWatcher;
@@ -12500,14 +12690,17 @@ function createBuildService(ctx) {
     return watcher;
   }
   async function runProd() {
-    _optionalChain([debug, 'optionalCall', _240 => _240("prod build start")]);
+    _optionalChain([debug, 'optionalCall', _246 => _246("prod build start")]);
     const { hasWorkersDir } = checkWorkersOptions();
     const bundlerPromise = _vite.build.call(void 0, 
-      configService.merge(void 0, sharedBuildConfig())
+      configService.merge(
+        void 0,
+        createSharedBuildConfig(configService, scanService)
+      )
     );
     const workerPromise = hasWorkersDir ? buildWorkers() : Promise.resolve();
     const [output] = await Promise.all([bundlerPromise, workerPromise]);
-    _optionalChain([debug, 'optionalCall', _241 => _241("prod build end")]);
+    _optionalChain([debug, 'optionalCall', _247 => _247("prod build end")]);
     return output;
   }
   async function buildEntry(options) {
@@ -12527,12 +12720,12 @@ function createBuildService(ctx) {
           }
         }
       );
-      _optionalChain([debug, 'optionalCall', _242 => _242("deletedFilePaths", deletedFilePaths)]);
+      _optionalChain([debug, 'optionalCall', _248 => _248("deletedFilePaths", deletedFilePaths)]);
       logger_default.success(`\u5DF2\u6E05\u7A7A ${configService.mpDistRoot} \u76EE\u5F55`);
     }
-    _optionalChain([debug, 'optionalCall', _243 => _243("build start")]);
+    _optionalChain([debug, 'optionalCall', _249 => _249("build start")]);
     let npmBuildTask = Promise.resolve();
-    if (!_optionalChain([options, 'optionalAccess', _244 => _244.skipNpm])) {
+    if (!_optionalChain([options, 'optionalAccess', _250 => _250.skipNpm])) {
       let shouldBuildNpm = true;
       if (configService.isDev) {
         const isDependenciesOutdated = await npmService.checkDependenciesCacheOutdate();
@@ -12559,7 +12752,7 @@ function createBuildService(ctx) {
       result = await runProd();
     }
     await npmBuildTask;
-    _optionalChain([debug, 'optionalCall', _245 => _245("build end")]);
+    _optionalChain([debug, 'optionalCall', _251 => _251("build end")]);
     return result;
   }
   return {
@@ -19515,7 +19708,7 @@ function _tryModuleResolve(id, url, conditions) {
   try {
     return moduleResolve(id, url, conditions);
   } catch (error) {
-    if (!NOT_FOUND_ERRORS.has(_optionalChain([error, 'optionalAccess', _246 => _246.code]))) {
+    if (!NOT_FOUND_ERRORS.has(_optionalChain([error, 'optionalAccess', _252 => _252.code]))) {
       throw error;
     }
   }
@@ -19544,7 +19737,7 @@ function _resolve(id, options = {}) {
         return pathToFileURL(id);
       }
     } catch (error) {
-      if (_optionalChain([error, 'optionalAccess', _247 => _247.code]) !== "ENOENT") {
+      if (_optionalChain([error, 'optionalAccess', _253 => _253.code]) !== "ENOENT") {
         throw error;
       }
     }
@@ -19688,10 +19881,10 @@ function fromGeneratorFn(generatorFn, options) {
   return fromObject({
     name: generatorFn.name,
     async(...args) {
-      return iterateAsync(generatorFn.apply(this, args), _optionalChain([options, 'optionalAccess', _248 => _248.onYield]));
+      return iterateAsync(generatorFn.apply(this, args), _optionalChain([options, 'optionalAccess', _254 => _254.onYield]));
     },
     sync(...args) {
-      return iterateSync2(generatorFn.apply(this, args), _optionalChain([options, 'optionalAccess', _249 => _249.onYield]));
+      return iterateSync2(generatorFn.apply(this, args), _optionalChain([options, 'optionalAccess', _255 => _255.onYield]));
     }
   });
 }
@@ -19750,7 +19943,7 @@ function findUpSync(name, {
     const filePath = isAbsoluteName ? name : sysPath2.default.join(directory, name);
     try {
       const stats = actualFS.default.statSync(filePath, { throwIfNoEntry: false });
-      if (type === "file" && _optionalChain([stats, 'optionalAccess', _250 => _250.isFile, 'call', _251 => _251()]) || type === "directory" && _optionalChain([stats, 'optionalAccess', _252 => _252.isDirectory, 'call', _253 => _253()])) {
+      if (type === "file" && _optionalChain([stats, 'optionalAccess', _256 => _256.isFile, 'call', _257 => _257()]) || type === "directory" && _optionalChain([stats, 'optionalAccess', _258 => _258.isDirectory, 'call', _259 => _259()])) {
         return filePath;
       }
     } catch (e18) {
@@ -19969,18 +20162,18 @@ async function detect(options = {}) {
         }
       }
     }
-    if (_optionalChain([stopDir, 'optionalCall', _254 => _254(directory)]))
+    if (_optionalChain([stopDir, 'optionalCall', _260 => _260(directory)]))
       break;
   }
   return null;
 }
 function getNameAndVer(pkg) {
-  const handelVer = (version2) => _nullishCoalesce(_optionalChain([version2, 'optionalAccess', _255 => _255.match, 'call', _256 => _256(/\d+(\.\d+){0,2}/), 'optionalAccess', _257 => _257[0]]), () => ( version2));
+  const handelVer = (version2) => _nullishCoalesce(_optionalChain([version2, 'optionalAccess', _261 => _261.match, 'call', _262 => _262(/\d+(\.\d+){0,2}/), 'optionalAccess', _263 => _263[0]]), () => ( version2));
   if (typeof pkg.packageManager === "string") {
     const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
     return { name, ver: handelVer(ver) };
   }
-  if (typeof _optionalChain([pkg, 'access', _258 => _258.devEngines, 'optionalAccess', _259 => _259.packageManager, 'optionalAccess', _260 => _260.name]) === "string") {
+  if (typeof _optionalChain([pkg, 'access', _264 => _264.devEngines, 'optionalAccess', _265 => _265.packageManager, 'optionalAccess', _266 => _266.name]) === "string") {
     return {
       name: pkg.devEngines.packageManager.name,
       ver: handelVer(pkg.devEngines.packageManager.version)
@@ -20008,7 +20201,7 @@ async function handlePackageManager(filepath, onUnknown) {
         agent = name;
         return { name, agent, version: version2 };
       } else {
-        return _nullishCoalesce(_optionalChain([onUnknown, 'optionalCall', _261 => _261(pkg.packageManager)]), () => ( null));
+        return _nullishCoalesce(_optionalChain([onUnknown, 'optionalCall', _267 => _267(pkg.packageManager)]), () => ( null));
       }
     }
   } catch (e23) {
@@ -20022,6 +20215,123 @@ function isMetadataYarnClassic(metadataPath) {
 // src/runtime/config/createConfigService.ts
 
 
+// src/platform.ts
+_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+
+// src/platforms/adapters.ts
+_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+var MINI_PROGRAM_PLATFORM_ADAPTERS = [
+  {
+    id: "weapp",
+    displayName: "WeChat Mini Program",
+    aliases: ["weapp", "wechat", "weixin", "wx"],
+    outputExtensions: {
+      js: "js",
+      json: "json",
+      wxml: "wxml",
+      wxss: "wxss",
+      wxs: "wxs"
+    }
+  },
+  {
+    id: "alipay",
+    displayName: "Alipay Mini Program",
+    aliases: ["alipay", "ali", "my"],
+    outputExtensions: {
+      js: "js",
+      json: "json",
+      wxml: "axml",
+      wxss: "acss",
+      wxs: "sjs"
+    }
+  },
+  {
+    id: "swan",
+    displayName: "Baidu Smart Program",
+    aliases: ["swan", "baidu", "bd"],
+    outputExtensions: {
+      js: "js",
+      json: "json",
+      wxml: "swan",
+      wxss: "css",
+      wxs: "sjs"
+    }
+  },
+  {
+    id: "tt",
+    displayName: "ByteDance / Douyin Mini Program",
+    aliases: ["tt", "toutiao", "bytedance", "douyin"],
+    outputExtensions: {
+      js: "js",
+      json: "json",
+      wxml: "ttml",
+      wxss: "ttss"
+    }
+  },
+  {
+    id: "jd",
+    displayName: "JD Mini Program",
+    aliases: ["jd", "jingdong"],
+    outputExtensions: {
+      js: "js",
+      json: "json",
+      wxml: "jxml",
+      wxss: "jxss",
+      wxs: "wxs"
+    }
+  },
+  {
+    id: "xhs",
+    displayName: "Xiaohongshu Mini Program",
+    aliases: ["xhs", "xiaohongshu", "little-red-book", "red"],
+    outputExtensions: {
+      js: "js",
+      json: "json",
+      wxml: "xhsml",
+      wxss: "css",
+      wxs: "wxs"
+    }
+  }
+];
+
+// src/platform.ts
+var DEFAULT_MP_PLATFORM = "weapp";
+var PLATFORM_ADAPTER_BY_ID = /* @__PURE__ */ new Map();
+var PLATFORM_ALIAS_TO_ID = /* @__PURE__ */ new Map();
+for (const adapter of MINI_PROGRAM_PLATFORM_ADAPTERS) {
+  PLATFORM_ADAPTER_BY_ID.set(adapter.id, adapter);
+  for (const alias of adapter.aliases) {
+    const normalized = alias.trim().toLowerCase();
+    if (!normalized) {
+      continue;
+    }
+    PLATFORM_ALIAS_TO_ID.set(normalized, adapter.id);
+  }
+  if (!PLATFORM_ALIAS_TO_ID.has(adapter.id)) {
+    PLATFORM_ALIAS_TO_ID.set(adapter.id, adapter.id);
+  }
+}
+var MINI_PLATFORM_ALIASES = Object.freeze(
+  Object.fromEntries(PLATFORM_ALIAS_TO_ID.entries())
+);
+function normalizeMiniPlatform(input) {
+  return input ? input.trim().toLowerCase() : void 0;
+}
+function resolveMiniPlatform(input) {
+  const normalized = normalizeMiniPlatform(input);
+  if (!normalized) {
+    return void 0;
+  }
+  return PLATFORM_ALIAS_TO_ID.get(normalized);
+}
+function getMiniProgramPlatformAdapter(platform) {
+  const adapter = PLATFORM_ADAPTER_BY_ID.get(platform);
+  if (!adapter) {
+    throw new Error(`Unsupported mini program platform "${platform}".`);
+  }
+  return adapter;
+}
+
 // src/runtime/oxcRuntime.ts
 _chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
 
@@ -20089,7 +20399,7 @@ export default _objectSpread2;`
 function getOxcHelperName(id) {
   OXC_RUNTIME_HELPER_ALIAS.lastIndex = 0;
   const match2 = OXC_RUNTIME_HELPER_ALIAS.exec(id);
-  return _optionalChain([match2, 'optionalAccess', _262 => _262[1]]);
+  return _optionalChain([match2, 'optionalAccess', _268 => _268[1]]);
 }
 function createOxcRuntimeSupport() {
   const oxcRuntimeInfo = getPackageInfoSync("@oxc-project/runtime");
@@ -20304,7 +20614,9 @@ function getWeappViteConfig() {
     },
     chunks: {
       sharedStrategy: "duplicate",
-      logOptimization: true
+      logOptimization: true,
+      forceDuplicatePatterns: [],
+      duplicateWarningBytes: 512 * 1024
     }
   };
 }
@@ -20345,13 +20657,13 @@ function migrateEnhanceOptions(target, options) {
   }
   const enhance = target.enhance;
   const userConfigured = _nullishCoalesce(options.userConfigured, () => ( {}));
-  if (!userConfigured.wxml && _optionalChain([enhance, 'optionalAccess', _263 => _263.wxml]) !== void 0) {
+  if (!userConfigured.wxml && _optionalChain([enhance, 'optionalAccess', _269 => _269.wxml]) !== void 0) {
     target.wxml = enhance.wxml;
   }
-  if (!userConfigured.wxs && _optionalChain([enhance, 'optionalAccess', _264 => _264.wxs]) !== void 0) {
+  if (!userConfigured.wxs && _optionalChain([enhance, 'optionalAccess', _270 => _270.wxs]) !== void 0) {
     target.wxs = enhance.wxs;
   }
-  if (!userConfigured.autoImportComponents && _optionalChain([enhance, 'optionalAccess', _265 => _265.autoImportComponents]) !== void 0) {
+  if (!userConfigured.autoImportComponents && _optionalChain([enhance, 'optionalAccess', _271 => _271.autoImportComponents]) !== void 0) {
     target.autoImportComponents = enhance.autoImportComponents;
   }
   if (options.warn && !hasLoggedEnhanceDeprecation) {
@@ -20516,7 +20828,7 @@ function normalizeSrcDir(root, cwd, srcRoot, config) {
   return _pathe2.default.relative(root, absoluteSrc) || "";
 }
 function normalizeOutDir(root, config) {
-  if (!_optionalChain([config, 'optionalAccess', _266 => _266.outDir])) {
+  if (!_optionalChain([config, 'optionalAccess', _272 => _272.outDir])) {
     return _pathe2.default.resolve(root, "dist-web");
   }
   if (_pathe2.default.isAbsolute(config.outDir)) {
@@ -20592,11 +20904,11 @@ function createLoadConfig(options) {
       command: isDev ? "serve" : "build",
       mode
     }, resolvedConfigFile, cwd);
-    const loadedConfig = _nullishCoalesce(_optionalChain([loaded, 'optionalAccess', _267 => _267.config]), () => ( {}));
+    const loadedConfig = _nullishCoalesce(_optionalChain([loaded, 'optionalAccess', _273 => _273.config]), () => ( {}));
     let weappLoaded;
     if (weappConfigFilePath) {
       const normalizedWeappPath = _pathe2.default.resolve(weappConfigFilePath);
-      const normalizedLoadedPath = _optionalChain([loaded, 'optionalAccess', _268 => _268.path]) ? _pathe2.default.resolve(loaded.path) : void 0;
+      const normalizedLoadedPath = _optionalChain([loaded, 'optionalAccess', _274 => _274.path]) ? _pathe2.default.resolve(loaded.path) : void 0;
       if (normalizedLoadedPath && normalizedLoadedPath === normalizedWeappPath) {
         weappLoaded = loaded;
       } else {
@@ -20629,47 +20941,47 @@ function createLoadConfig(options) {
         weapp: getWeappViteConfig()
       }
     );
-    if (_optionalChain([weappLoaded, 'optionalAccess', _269 => _269.config, 'optionalAccess', _270 => _270.weapp])) {
+    if (_optionalChain([weappLoaded, 'optionalAccess', _275 => _275.config, 'optionalAccess', _276 => _276.weapp])) {
       config.weapp = _shared.defu.call(void 0, 
         weappLoaded.config.weapp,
         _nullishCoalesce(config.weapp, () => ( {}))
       );
     }
     const shouldWarnEnhance = [
-      _optionalChain([inlineConfig, 'optionalAccess', _271 => _271.weapp, 'optionalAccess', _272 => _272.enhance]),
-      _optionalChain([loadedConfig, 'access', _273 => _273.weapp, 'optionalAccess', _274 => _274.enhance]),
-      _optionalChain([weappLoaded, 'optionalAccess', _275 => _275.config, 'optionalAccess', _276 => _276.weapp, 'optionalAccess', _277 => _277.enhance])
+      _optionalChain([inlineConfig, 'optionalAccess', _277 => _277.weapp, 'optionalAccess', _278 => _278.enhance]),
+      _optionalChain([loadedConfig, 'access', _279 => _279.weapp, 'optionalAccess', _280 => _280.enhance]),
+      _optionalChain([weappLoaded, 'optionalAccess', _281 => _281.config, 'optionalAccess', _282 => _282.weapp, 'optionalAccess', _283 => _283.enhance])
     ].some(hasDeprecatedEnhanceUsage);
     const userConfiguredTopLevel = {
       wxml: [
-        _optionalChain([inlineConfig, 'optionalAccess', _278 => _278.weapp, 'optionalAccess', _279 => _279.wxml]),
-        _optionalChain([loadedConfig, 'access', _280 => _280.weapp, 'optionalAccess', _281 => _281.wxml]),
-        _optionalChain([weappLoaded, 'optionalAccess', _282 => _282.config, 'optionalAccess', _283 => _283.weapp, 'optionalAccess', _284 => _284.wxml])
+        _optionalChain([inlineConfig, 'optionalAccess', _284 => _284.weapp, 'optionalAccess', _285 => _285.wxml]),
+        _optionalChain([loadedConfig, 'access', _286 => _286.weapp, 'optionalAccess', _287 => _287.wxml]),
+        _optionalChain([weappLoaded, 'optionalAccess', _288 => _288.config, 'optionalAccess', _289 => _289.weapp, 'optionalAccess', _290 => _290.wxml])
       ].some((value) => value !== void 0),
       wxs: [
-        _optionalChain([inlineConfig, 'optionalAccess', _285 => _285.weapp, 'optionalAccess', _286 => _286.wxs]),
-        _optionalChain([loadedConfig, 'access', _287 => _287.weapp, 'optionalAccess', _288 => _288.wxs]),
-        _optionalChain([weappLoaded, 'optionalAccess', _289 => _289.config, 'optionalAccess', _290 => _290.weapp, 'optionalAccess', _291 => _291.wxs])
+        _optionalChain([inlineConfig, 'optionalAccess', _291 => _291.weapp, 'optionalAccess', _292 => _292.wxs]),
+        _optionalChain([loadedConfig, 'access', _293 => _293.weapp, 'optionalAccess', _294 => _294.wxs]),
+        _optionalChain([weappLoaded, 'optionalAccess', _295 => _295.config, 'optionalAccess', _296 => _296.weapp, 'optionalAccess', _297 => _297.wxs])
       ].some((value) => value !== void 0),
       autoImportComponents: [
-        _optionalChain([inlineConfig, 'optionalAccess', _292 => _292.weapp, 'optionalAccess', _293 => _293.autoImportComponents]),
-        _optionalChain([loadedConfig, 'access', _294 => _294.weapp, 'optionalAccess', _295 => _295.autoImportComponents]),
-        _optionalChain([weappLoaded, 'optionalAccess', _296 => _296.config, 'optionalAccess', _297 => _297.weapp, 'optionalAccess', _298 => _298.autoImportComponents])
+        _optionalChain([inlineConfig, 'optionalAccess', _298 => _298.weapp, 'optionalAccess', _299 => _299.autoImportComponents]),
+        _optionalChain([loadedConfig, 'access', _300 => _300.weapp, 'optionalAccess', _301 => _301.autoImportComponents]),
+        _optionalChain([weappLoaded, 'optionalAccess', _302 => _302.config, 'optionalAccess', _303 => _303.weapp, 'optionalAccess', _304 => _304.autoImportComponents])
       ].some((value) => value !== void 0)
     };
     migrateEnhanceOptions(config.weapp, {
       warn: shouldWarnEnhance,
       userConfigured: userConfiguredTopLevel
     });
-    const srcRoot = _nullishCoalesce(_optionalChain([config, 'access', _299 => _299.weapp, 'optionalAccess', _300 => _300.srcRoot]), () => ( ""));
+    const srcRoot = _nullishCoalesce(_optionalChain([config, 'access', _305 => _305.weapp, 'optionalAccess', _306 => _306.srcRoot]), () => ( ""));
     const resolvedWebConfig = resolveWeappWebConfig({
       cwd,
       srcRoot,
-      config: _optionalChain([config, 'access', _301 => _301.weapp, 'optionalAccess', _302 => _302.web])
+      config: _optionalChain([config, 'access', _307 => _307.weapp, 'optionalAccess', _308 => _308.web])
     });
     const buildConfig = _nullishCoalesce(config.build, () => ( (config.build = {})));
-    const jsFormat = _nullishCoalesce(_optionalChain([config, 'access', _303 => _303.weapp, 'optionalAccess', _304 => _304.jsFormat]), () => ( "cjs"));
-    const enableLegacyEs5 = _optionalChain([config, 'access', _305 => _305.weapp, 'optionalAccess', _306 => _306.es5]) === true;
+    const jsFormat = _nullishCoalesce(_optionalChain([config, 'access', _309 => _309.weapp, 'optionalAccess', _310 => _310.jsFormat]), () => ( "cjs"));
+    const enableLegacyEs5 = _optionalChain([config, 'access', _311 => _311.weapp, 'optionalAccess', _312 => _312.es5]) === true;
     if (enableLegacyEs5 && jsFormat !== "cjs") {
       throw new Error('`weapp.es5` \u4EC5\u652F\u6301\u5728 `weapp.jsFormat` \u4E3A "cjs" \u65F6\u4F7F\u7528\uFF0C\u8BF7\u5207\u6362\u5230 CommonJS \u6216\u5173\u95ED\u8BE5\u9009\u9879\u3002');
     }
@@ -20716,11 +21028,11 @@ function createLoadConfig(options) {
       config.plugins ??= [];
       config.plugins.unshift(oxcVitePlugin);
     }
-    const platform = _nullishCoalesce(_optionalChain([config, 'access', _307 => _307.weapp, 'optionalAccess', _308 => _308.platform]), () => ( DEFAULT_MP_PLATFORM));
-    const aliasEntries = getAliasEntries(_optionalChain([config, 'access', _309 => _309.weapp, 'optionalAccess', _310 => _310.jsonAlias]));
+    const platform = _nullishCoalesce(_optionalChain([config, 'access', _313 => _313.weapp, 'optionalAccess', _314 => _314.platform]), () => ( DEFAULT_MP_PLATFORM));
+    const aliasEntries = getAliasEntries(_optionalChain([config, 'access', _315 => _315.weapp, 'optionalAccess', _316 => _316.jsonAlias]));
     config.plugins ??= [];
-    config.plugins.push(_vitetsconfigpaths2.default.call(void 0, _optionalChain([config, 'access', _311 => _311.weapp, 'optionalAccess', _312 => _312.tsconfigPaths])));
-    const configFilePath = _nullishCoalesce(_nullishCoalesce(_optionalChain([weappLoaded, 'optionalAccess', _313 => _313.path]), () => ( _optionalChain([loaded, 'optionalAccess', _314 => _314.path]))), () => ( resolvedConfigFile));
+    config.plugins.push(_vitetsconfigpaths2.default.call(void 0, _optionalChain([config, 'access', _317 => _317.weapp, 'optionalAccess', _318 => _318.tsconfigPaths])));
+    const configFilePath = _nullishCoalesce(_nullishCoalesce(_optionalChain([weappLoaded, 'optionalAccess', _319 => _319.path]), () => ( _optionalChain([loaded, 'optionalAccess', _320 => _320.path]))), () => ( resolvedConfigFile));
     const outputExtensions = getOutputExtensions(platform);
     const relativeSrcRoot = (p) => {
       if (srcRoot) {
@@ -20769,9 +21081,9 @@ function normalizeCopyGlobs(globs) {
 }
 function scanAssetFiles(configService, config) {
   const weappViteConfig = configService.weappViteConfig;
-  const include = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _315 => _315.copy, 'optionalAccess', _316 => _316.include]));
-  const exclude = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _317 => _317.copy, 'optionalAccess', _318 => _318.exclude]));
-  const filter3 = _nullishCoalesce(_optionalChain([weappViteConfig, 'optionalAccess', _319 => _319.copy, 'optionalAccess', _320 => _320.filter]), () => ( (() => true)));
+  const include = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _321 => _321.copy, 'optionalAccess', _322 => _322.include]));
+  const exclude = normalizeCopyGlobs(_optionalChain([weappViteConfig, 'optionalAccess', _323 => _323.copy, 'optionalAccess', _324 => _324.exclude]));
+  const filter3 = _nullishCoalesce(_optionalChain([weappViteConfig, 'optionalAccess', _325 => _325.copy, 'optionalAccess', _326 => _326.filter]), () => ( (() => true)));
   const ignore = [
     ...defaultExcluded,
     _pathe2.default.resolve(configService.cwd, `${config.build.outDir}/**/*`),
@@ -20829,7 +21141,7 @@ function createAssetCollector(state) {
     },
     async buildEnd() {
       const assets = await state.pendingAssets;
-      if (!_optionalChain([assets, 'optionalAccess', _321 => _321.length])) {
+      if (!_optionalChain([assets, 'optionalAccess', _327 => _327.length])) {
         return;
       }
       for (const candidate of assets) {
@@ -20931,13 +21243,13 @@ function createAutoImportPlugin(state) {
         return;
       }
       const weappConfig = configService.weappViteConfig;
-      const globs = _nullishCoalesce(_optionalChain([weappConfig, 'optionalAccess', _322 => _322.autoImportComponents, 'optionalAccess', _323 => _323.globs]), () => ( _optionalChain([weappConfig, 'optionalAccess', _324 => _324.enhance, 'optionalAccess', _325 => _325.autoImportComponents, 'optionalAccess', _326 => _326.globs])));
-      const globsKey = _nullishCoalesce(_optionalChain([globs, 'optionalAccess', _327 => _327.join, 'call', _328 => _328("\0")]), () => ( ""));
+      const globs = _nullishCoalesce(_optionalChain([weappConfig, 'optionalAccess', _328 => _328.autoImportComponents, 'optionalAccess', _329 => _329.globs]), () => ( _optionalChain([weappConfig, 'optionalAccess', _330 => _330.enhance, 'optionalAccess', _331 => _331.autoImportComponents, 'optionalAccess', _332 => _332.globs])));
+      const globsKey = _nullishCoalesce(_optionalChain([globs, 'optionalAccess', _333 => _333.join, 'call', _334 => _334("\0")]), () => ( ""));
       if (globsKey !== state.lastGlobsKey) {
         state.initialScanDone = false;
         state.lastGlobsKey = globsKey;
       }
-      if (!_optionalChain([globs, 'optionalAccess', _329 => _329.length])) {
+      if (!_optionalChain([globs, 'optionalAccess', _335 => _335.length])) {
         return;
       }
       if (state.initialScanDone) {
@@ -21028,14 +21340,14 @@ function createAutoRoutesPlugin(ctx) {
       if (!service.isRouteFile(id)) {
         return;
       }
-      const event = _optionalChain([change, 'optionalAccess', _330 => _330.event]);
+      const event = _optionalChain([change, 'optionalAccess', _336 => _336.event]);
       await service.handleFileChange(id, event);
     },
     async handleHotUpdate(context) {
       if (!service.isRouteFile(context.file)) {
         return;
       }
-      if (_optionalChain([resolvedConfig, 'optionalAccess', _331 => _331.command]) === "serve") {
+      if (_optionalChain([resolvedConfig, 'optionalAccess', _337 => _337.command]) === "serve") {
         await service.handleFileChange(context.file, "update");
       }
       const virtualModule = context.server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ID);
@@ -21259,7 +21571,7 @@ async function renderSharedStyleEntry(entry, _configService, resolvedConfig) {
       };
     }
     const processed = await _vite.preprocessCSS.call(void 0, css2, absolutePath, resolvedConfig);
-    const dependencies = _optionalChain([processed, 'optionalAccess', _332 => _332.deps]) ? dedupeAndNormalizeDependencies(absolutePath, processed.deps) : [];
+    const dependencies = _optionalChain([processed, 'optionalAccess', _338 => _338.deps]) ? dedupeAndNormalizeDependencies(absolutePath, processed.deps) : [];
     const result = {
       css: processed.code,
       dependencies
@@ -21295,10 +21607,10 @@ function invalidateSharedStyleCache() {
       try {
         const sharedState = _chunkA5DD7GKXcjs.__require.call(void 0, request);
         if (sharedState) {
-          _optionalChain([sharedState, 'access', _333 => _333.contextMap, 'optionalAccess', _334 => _334.clear, 'optionalCall', _335 => _335()]);
-          _optionalChain([sharedState, 'access', _336 => _336.configContextMap, 'optionalAccess', _337 => _337.clear, 'optionalCall', _338 => _338()]);
-          _optionalChain([sharedState, 'access', _339 => _339.contextSourcesMap, 'optionalAccess', _340 => _340.clear, 'optionalCall', _341 => _341()]);
-          _optionalChain([sharedState, 'access', _342 => _342.sourceHashMap, 'optionalAccess', _343 => _343.clear, 'optionalCall', _344 => _344()]);
+          _optionalChain([sharedState, 'access', _339 => _339.contextMap, 'optionalAccess', _340 => _340.clear, 'optionalCall', _341 => _341()]);
+          _optionalChain([sharedState, 'access', _342 => _342.configContextMap, 'optionalAccess', _343 => _343.clear, 'optionalCall', _344 => _344()]);
+          _optionalChain([sharedState, 'access', _345 => _345.contextSourcesMap, 'optionalAccess', _346 => _346.clear, 'optionalCall', _347 => _347()]);
+          _optionalChain([sharedState, 'access', _348 => _348.sourceHashMap, 'optionalAccess', _349 => _349.clear, 'optionalCall', _350 => _350()]);
           break;
         }
       } catch (e26) {
@@ -21358,7 +21670,7 @@ function createChunkEmitter(configService, loadedEntrySet, debug4) {
         // @ts-ignore
         preserveSignature: "exports-only"
       });
-      _optionalChain([debug4, 'optionalCall', _345 => _345(`load ${fileName} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
+      _optionalChain([debug4, 'optionalCall', _351 => _351(`load ${fileName} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
     });
   };
 }
@@ -22665,7 +22977,7 @@ function createEntryLoader(options) {
         registerJsonAsset,
         existsCache
       );
-      const pluginJsonPath = _optionalChain([scanService, 'optionalAccess', _346 => _346.pluginJsonPath]);
+      const pluginJsonPath = _optionalChain([scanService, 'optionalAccess', _352 => _352.pluginJsonPath]);
       if (configService.absolutePluginRoot && pluginJsonPath) {
         this.addWatchFile(pluginJsonPath);
         const pluginJson = await jsonService.read(pluginJsonPath);
@@ -22713,13 +23025,13 @@ function createEntryLoader(options) {
       normalizedEntries,
       configService.absoluteSrcRoot
     );
-    _optionalChain([debug4, 'optionalCall', _347 => _347(`resolvedIds ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
+    _optionalChain([debug4, 'optionalCall', _353 => _353(`resolvedIds ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
     const pendingResolvedIds = [];
     const combinedResolved = pluginResolvedRecords ? [...resolvedIds, ...pluginResolvedRecords] : resolvedIds;
     const pluginEntrySet = pluginResolvedRecords ? new Set(pluginResolvedRecords.map((record) => record.entry)) : void 0;
     for (const { entry, resolvedId } of combinedResolved) {
       if (!resolvedId) {
-        if (_optionalChain([pluginEntrySet, 'optionalAccess', _348 => _348.has, 'call', _349 => _349(entry)])) {
+        if (_optionalChain([pluginEntrySet, 'optionalAccess', _354 => _354.has, 'call', _355 => _355(entry)])) {
           logger_default.warn(`\u6CA1\u6709\u627E\u5230\u63D2\u4EF6\u5165\u53E3 \`${entry}\` \u5BF9\u5E94\u7684\u811A\u672C\u6587\u4EF6\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84\u662F\u5426\u6B63\u786E!`);
         } else {
           logger_default.warn(`\u6CA1\u6709\u627E\u5230 \`${entry}\` \u7684\u5165\u53E3\u6587\u4EF6\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84\u662F\u5426\u6B63\u786E!`);
@@ -22734,7 +23046,7 @@ function createEntryLoader(options) {
     if (pendingResolvedIds.length) {
       await Promise.all(emitEntriesChunks.call(this, pendingResolvedIds));
     }
-    _optionalChain([debug4, 'optionalCall', _350 => _350(`emitEntriesChunks ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
+    _optionalChain([debug4, 'optionalCall', _356 => _356(`emitEntriesChunks ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
     registerJsonAsset({
       jsonPath,
       json,
@@ -22749,7 +23061,7 @@ function createEntryLoader(options) {
     }
     const code = await _fsextra2.default.readFile(id, "utf8");
     const styleImports = await collectStyleImports(this, id, existsCache);
-    _optionalChain([debug4, 'optionalCall', _351 => _351(`loadEntry ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
+    _optionalChain([debug4, 'optionalCall', _357 => _357(`loadEntry ${relativeCwdId} \u8017\u65F6 ${getTime()}`)]);
     if (styleImports.length === 0) {
       return {
         code
@@ -22820,7 +23132,7 @@ function createTemplateScanner(wxmlService, debug4) {
       const { components: components2 } = wxmlToken;
       wxmlService.setWxmlComponentsMap(templateEntry, components2);
     }
-    _optionalChain([debug4, 'optionalCall', _352 => _352(`scanTemplateEntry ${templateEntry} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
+    _optionalChain([debug4, 'optionalCall', _358 => _358(`scanTemplateEntry ${templateEntry} \u8017\u65F6 ${(_perf_hooks.performance.now() - start).toFixed(2)}ms`)]);
   };
 }
 
@@ -22994,7 +23306,7 @@ async function extractCssImportDependencies(ctx, importer) {
     if (!match2) {
       break;
     }
-    const rawSpecifier = _optionalChain([match2, 'access', _353 => _353[1], 'optionalAccess', _354 => _354.trim, 'call', _355 => _355()]);
+    const rawSpecifier = _optionalChain([match2, 'access', _359 => _359[1], 'optionalAccess', _360 => _360.trim, 'call', _361 => _361()]);
     if (!rawSpecifier) {
       continue;
     }
@@ -23212,7 +23524,7 @@ function ensureSidecarWatcher(ctx, rootDir) {
       return;
     }
     const normalizedPath = _pathe2.default.normalize(input);
-    if (!_optionalChain([options, 'optionalAccess', _356 => _356.silent])) {
+    if (!_optionalChain([options, 'optionalAccess', _362 => _362.silent])) {
       logger_default.info(`[watch:${event}] ${ctx.configService.relativeCwd(normalizedPath)}`);
     }
     handleSidecarChange(event, normalizedPath, isReady);
@@ -23244,7 +23556,7 @@ function ensureSidecarWatcher(ctx, rootDir) {
       return;
     }
     const relativeRoot = ctx.configService.relativeCwd(absRoot);
-    const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _357 => _357.code]), () => ( "UNKNOWN"));
+    const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _363 => _363.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, {
@@ -23408,7 +23720,7 @@ function createCacheKey(options) {
   return `${options.removeComment ? 1 : 0}|${options.transformEvent ? 1 : 0}`;
 }
 function getCachedResult(data2, cacheKey) {
-  return _optionalChain([handleCache, 'access', _358 => _358.get, 'call', _359 => _359(data2), 'optionalAccess', _360 => _360.get, 'call', _361 => _361(cacheKey)]);
+  return _optionalChain([handleCache, 'access', _364 => _364.get, 'call', _365 => _365(data2), 'optionalAccess', _366 => _366.get, 'call', _367 => _367(cacheKey)]);
 }
 function setCachedResult(data2, cacheKey, result) {
   let cacheForToken = handleCache.get(data2);
@@ -23484,7 +23796,7 @@ function handleWxml(data2, options) {
   if (shouldTransformInlineWxs) {
     for (const { end, start, value } of inlineWxsTokens) {
       const { result } = getCachedInlineWxsTransform(value);
-      if (_optionalChain([result, 'optionalAccess', _362 => _362.code])) {
+      if (_optionalChain([result, 'optionalAccess', _368 => _368.code])) {
         ms.update(start, end, `
 ${result.code}`);
       }
@@ -23535,11 +23847,11 @@ function emitWxmlAssetsWithCache(options) {
   });
   const emittedFiles = [];
   for (const { id, fileName, token } of currentPackageWxmls) {
-    _optionalChain([runtime, 'access', _363 => _363.addWatchFile, 'optionalCall', _364 => _364(id)]);
+    _optionalChain([runtime, 'access', _369 => _369.addWatchFile, 'optionalCall', _370 => _370(id)]);
     const deps = wxmlService.depsMap.get(id);
     if (deps) {
       for (const dep of deps) {
-        _optionalChain([runtime, 'access', _365 => _365.addWatchFile, 'optionalCall', _366 => _366(dep)]);
+        _optionalChain([runtime, 'access', _371 => _371.addWatchFile, 'optionalCall', _372 => _372(dep)]);
       }
     }
     emittedFiles.push(fileName);
@@ -23635,7 +23947,7 @@ function createCoreLifecyclePlugin(state) {
           buildService.invalidateIndependentOutput(independentRoot);
           scanService.markIndependentDirty(independentRoot);
           handledByIndependentWatcher = true;
-          if (_optionalChain([independentMeta, 'optionalAccess', _367 => _367.watchSharedStyles]) !== false) {
+          if (_optionalChain([independentMeta, 'optionalAccess', _373 => _373.watchSharedStyles]) !== false) {
             invalidateSharedStyleCache();
           }
         }
@@ -23683,7 +23995,7 @@ function createCoreLifecyclePlugin(state) {
       options.input = scannedInput;
     },
     async load(id) {
-      _optionalChain([configService, 'access', _368 => _368.weappViteConfig, 'optionalAccess', _369 => _369.debug, 'optionalAccess', _370 => _370.load, 'optionalCall', _371 => _371(id, subPackageMeta)]);
+      _optionalChain([configService, 'access', _374 => _374.weappViteConfig, 'optionalAccess', _375 => _375.debug, 'optionalAccess', _376 => _376.load, 'optionalCall', _377 => _377(id, subPackageMeta)]);
       const relativeBasename = _shared.removeExtensionDeep.call(void 0, configService.relativeAbsoluteSrcRoot(id));
       if (isCSSRequest(id)) {
         const parsed = parseRequest(id);
@@ -23697,7 +24009,7 @@ function createCoreLifecyclePlugin(state) {
         }
         return null;
       }
-      if (loadedEntrySet.has(id) || _optionalChain([subPackageMeta, 'optionalAccess', _372 => _372.entries, 'access', _373 => _373.includes, 'call', _374 => _374(relativeBasename)])) {
+      if (loadedEntrySet.has(id) || _optionalChain([subPackageMeta, 'optionalAccess', _378 => _378.entries, 'access', _379 => _379.includes, 'call', _380 => _380(relativeBasename)])) {
         return await loadEntry.call(this, id, "component");
       }
       if (relativeBasename === "app") {
@@ -23728,13 +24040,19 @@ function createCoreLifecyclePlugin(state) {
           return subPackageRoots.find((root) => filePath === root || filePath.startsWith(`${root}/`));
         };
         var matchSubPackage = matchSubPackage2;
-        const sharedStrategy = _nullishCoalesce(_optionalChain([configService, 'access', _375 => _375.weappViteConfig, 'optionalAccess', _376 => _376.chunks, 'optionalAccess', _377 => _377.sharedStrategy]), () => ( DEFAULT_SHARED_CHUNK_STRATEGY));
-        const shouldLogChunks = _nullishCoalesce(_optionalChain([configService, 'access', _378 => _378.weappViteConfig, 'optionalAccess', _379 => _379.chunks, 'optionalAccess', _380 => _380.logOptimization]), () => ( true));
+        const sharedStrategy = _nullishCoalesce(_optionalChain([configService, 'access', _381 => _381.weappViteConfig, 'optionalAccess', _382 => _382.chunks, 'optionalAccess', _383 => _383.sharedStrategy]), () => ( DEFAULT_SHARED_CHUNK_STRATEGY));
+        const shouldLogChunks = _nullishCoalesce(_optionalChain([configService, 'access', _384 => _384.weappViteConfig, 'optionalAccess', _385 => _385.chunks, 'optionalAccess', _386 => _386.logOptimization]), () => ( true));
         const subPackageRoots = Array.from(scanService.subPackageMap.keys()).filter(Boolean);
-        applySharedChunkStrategy.call(this, bundle, {
-          strategy: sharedStrategy,
-          subPackageRoots,
-          onDuplicate: shouldLogChunks ? ({ duplicates }) => {
+        const duplicateWarningBytes = Number(_nullishCoalesce(_optionalChain([configService, 'access', _387 => _387.weappViteConfig, 'optionalAccess', _388 => _388.chunks, 'optionalAccess', _389 => _389.duplicateWarningBytes]), () => ( 0)));
+        const shouldWarnOnDuplicate = Number.isFinite(duplicateWarningBytes) && duplicateWarningBytes > 0;
+        let redundantBytesTotal = 0;
+        const handleDuplicate = shouldLogChunks || shouldWarnOnDuplicate ? ({ duplicates, ignoredMainImporters, chunkBytes, redundantBytes }) => {
+          if (shouldWarnOnDuplicate) {
+            const duplicateCount = duplicates.length;
+            const computedRedundant = typeof redundantBytes === "number" ? redundantBytes : typeof chunkBytes === "number" ? chunkBytes * Math.max(duplicateCount - 1, 0) : 0;
+            redundantBytesTotal += computedRedundant;
+          }
+          if (shouldLogChunks) {
             const subPackageSet = /* @__PURE__ */ new Set();
             let totalReferences = 0;
             for (const { fileName, importers } of duplicates) {
@@ -23745,8 +24063,14 @@ function createCoreLifecyclePlugin(state) {
               }
             }
             const subPackageList = Array.from(subPackageSet).join("\u3001") || "\u76F8\u5173\u5206\u5305";
-            logger_default.info(`[subpackages] \u5206\u5305 ${subPackageList} \u5171\u4EAB\u6A21\u5757\u5DF2\u590D\u5236\u5230\u5404\u81EA weapp-shared/common.js\uFF08${totalReferences} \u5904\u5F15\u7528\uFF09`);
-          } : void 0,
+            const ignoredHint = _optionalChain([ignoredMainImporters, 'optionalAccess', _390 => _390.length]) ? `\uFF0C\u5FFD\u7565\u4E3B\u5305\u5F15\u7528\uFF1A${ignoredMainImporters.join("\u3001")}` : "";
+            logger_default.info(`[subpackages] \u5206\u5305 ${subPackageList} \u5171\u4EAB\u6A21\u5757\u5DF2\u590D\u5236\u5230\u5404\u81EA weapp-shared/common.js\uFF08${totalReferences} \u5904\u5F15\u7528${ignoredHint}\uFF09`);
+          }
+        } : void 0;
+        applySharedChunkStrategy.call(this, bundle, {
+          strategy: sharedStrategy,
+          subPackageRoots,
+          onDuplicate: handleDuplicate,
           onFallback: shouldLogChunks ? ({ reason, importers }) => {
             const involvedSubs = /* @__PURE__ */ new Set();
             let hasMainReference = false;
@@ -23773,11 +24097,14 @@ function createCoreLifecyclePlugin(state) {
             }
           } : void 0
         });
+        if (shouldWarnOnDuplicate && redundantBytesTotal > duplicateWarningBytes) {
+          logger_default.warn(`[subpackages] \u5206\u5305\u590D\u5236\u5171\u4EAB\u6A21\u5757\u4EA7\u751F\u5197\u4F59\u4F53\u79EF ${formatBytes(redundantBytesTotal)}\uFF0C\u5DF2\u8D85\u8FC7\u9608\u503C ${formatBytes(duplicateWarningBytes)}\uFF0C\u5EFA\u8BAE\u8C03\u6574\u5206\u5305\u5212\u5206\u6216\u8FD0\u884C weapp-vite analyze \u5B9A\u4F4D\u95EE\u9898\u3002`);
+        }
       }
-      if (_optionalChain([configService, 'access', _381 => _381.weappViteConfig, 'optionalAccess', _382 => _382.debug, 'optionalAccess', _383 => _383.watchFiles])) {
+      if (_optionalChain([configService, 'access', _391 => _391.weappViteConfig, 'optionalAccess', _392 => _392.debug, 'optionalAccess', _393 => _393.watchFiles])) {
         const watcherService = ctx.watcherService;
-        const watcherRoot = _nullishCoalesce(_optionalChain([subPackageMeta, 'optionalAccess', _384 => _384.subPackage, 'access', _385 => _385.root]), () => ( "/"));
-        const watcher = _optionalChain([watcherService, 'optionalAccess', _386 => _386.getRollupWatcher, 'call', _387 => _387(watcherRoot)]);
+        const watcherRoot = _nullishCoalesce(_optionalChain([subPackageMeta, 'optionalAccess', _394 => _394.subPackage, 'access', _395 => _395.root]), () => ( "/"));
+        const watcher = _optionalChain([watcherService, 'optionalAccess', _396 => _396.getRollupWatcher, 'call', _397 => _397(watcherRoot)]);
         let watchFiles;
         if (watcher && typeof watcher.getWatchFiles === "function") {
           watchFiles = await watcher.getWatchFiles();
@@ -23791,7 +24118,7 @@ function createCoreLifecyclePlugin(state) {
       }
     },
     buildEnd() {
-      _optionalChain([debug2, 'optionalCall', _388 => _388(`${subPackageMeta ? `\u72EC\u7ACB\u5206\u5305 ${subPackageMeta.subPackage.root}` : "\u4E3B\u5305"} ${Array.from(this.getModuleIds()).length} \u4E2A\u6A21\u5757\u88AB\u7F16\u8BD1`)]);
+      _optionalChain([debug2, 'optionalCall', _398 => _398(`${subPackageMeta ? `\u72EC\u7ACB\u5206\u5305 ${subPackageMeta.subPackage.root}` : "\u4E3B\u5305"} ${Array.from(this.getModuleIds()).length} \u4E2A\u6A21\u5757\u88AB\u7F16\u8BD1`)]);
     }
   };
 }
@@ -23848,6 +24175,21 @@ function createRequireAnalysisPlugin(state) {
     }
   };
 }
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0) {
+    return "0 B";
+  }
+  const units = ["B", "KB", "MB", "GB"];
+  let value = bytes;
+  let index = 0;
+  while (value >= 1024 && index < units.length - 1) {
+    value /= 1024;
+    index++;
+  }
+  const precision = value >= 100 ? 0 : value >= 10 ? 1 : 2;
+  const formatted = value.toFixed(precision).replace(/\.0+$/, "");
+  return `${formatted} ${units[index]}`;
+}
 function emitJsonAssets(state) {
   const { ctx } = state;
   const { jsonService } = ctx;
@@ -23875,7 +24217,7 @@ async function flushIndependentBuilds(state) {
   }
   const outputs = await Promise.all(pendingIndependentBuilds);
   for (const { rollup } of outputs) {
-    const bundleOutputs = Array.isArray(_optionalChain([rollup, 'optionalAccess', _389 => _389.output])) ? rollup.output : [];
+    const bundleOutputs = Array.isArray(_optionalChain([rollup, 'optionalAccess', _399 => _399.output])) ? rollup.output : [];
     for (const output of bundleOutputs) {
       if (output.type === "chunk") {
         this.emitFile({
@@ -23912,13 +24254,13 @@ function toPosixPath(value) {
 var styleMatcherCache = /* @__PURE__ */ new WeakMap();
 function collectSharedStyleEntries(ctx, configService) {
   const map = /* @__PURE__ */ new Map();
-  const registry = _optionalChain([ctx, 'access', _390 => _390.scanService, 'optionalAccess', _391 => _391.subPackageMap]);
-  if (!_optionalChain([registry, 'optionalAccess', _392 => _392.size])) {
+  const registry = _optionalChain([ctx, 'access', _400 => _400.scanService, 'optionalAccess', _401 => _401.subPackageMap]);
+  if (!_optionalChain([registry, 'optionalAccess', _402 => _402.size])) {
     return map;
   }
   const currentRoot = configService.currentSubPackageRoot;
   for (const [root, meta] of registry.entries()) {
-    if (!_optionalChain([meta, 'access', _393 => _393.styleEntries, 'optionalAccess', _394 => _394.length])) {
+    if (!_optionalChain([meta, 'access', _403 => _403.styleEntries, 'optionalAccess', _404 => _404.length])) {
       continue;
     }
     if (currentRoot && root !== currentRoot) {
@@ -23963,12 +24305,12 @@ function getStyleMatcher(entry) {
   if (cached) {
     return cached;
   }
-  const includePatterns = _optionalChain([entry, 'access', _395 => _395.include, 'optionalAccess', _396 => _396.length]) ? entry.include : ["**/*"];
-  const excludePatterns = _optionalChain([entry, 'access', _397 => _397.exclude, 'optionalAccess', _398 => _398.length]) ? entry.exclude : void 0;
+  const includePatterns = _optionalChain([entry, 'access', _405 => _405.include, 'optionalAccess', _406 => _406.length]) ? entry.include : ["**/*"];
+  const excludePatterns = _optionalChain([entry, 'access', _407 => _407.exclude, 'optionalAccess', _408 => _408.length]) ? entry.exclude : void 0;
   const matcher = {
     include: _picomatch2.default.call(void 0, includePatterns, { dot: true })
   };
-  if (_optionalChain([excludePatterns, 'optionalAccess', _399 => _399.length])) {
+  if (_optionalChain([excludePatterns, 'optionalAccess', _409 => _409.length])) {
     matcher.exclude = _picomatch2.default.call(void 0, excludePatterns, { dot: true });
   }
   styleMatcherCache.set(entry, matcher);
@@ -24073,7 +24415,7 @@ function injectSharedStyleImports(css2, modulePath, fileName, sharedStyles, conf
   }
   const normalizedFileName = toPosixPath(fileName);
   const entries = findSharedStylesForModule(normalizedModule, normalizedFileName, sharedStyles);
-  if (!_optionalChain([entries, 'optionalAccess', _400 => _400.length])) {
+  if (!_optionalChain([entries, 'optionalAccess', _410 => _410.length])) {
     return css2;
   }
   const specifiers = resolveImportSpecifiers(fileName, entries);
@@ -24285,14 +24627,14 @@ function createPluginPruner() {
     name: "weapp-vite:preflight",
     enforce: "pre",
     configResolved(config) {
-      if (!_optionalChain([config, 'access', _401 => _401.plugins, 'optionalAccess', _402 => _402.length])) {
+      if (!_optionalChain([config, 'access', _411 => _411.plugins, 'optionalAccess', _412 => _412.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', _403 => _403("remove plugin", plugin.name)]);
+          plugin && _optionalChain([debug3, 'optionalCall', _413 => _413("remove plugin", plugin.name)]);
         }
       }
     }
@@ -24348,8 +24690,8 @@ function createWorkerBuildPlugin(ctx) {
     name: "weapp-vite:workers",
     enforce: "pre",
     async options(options) {
-      const workerConfig = _optionalChain([configService, 'access', _404 => _404.weappViteConfig, 'optionalAccess', _405 => _405.worker]);
-      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _406 => _406.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _407 => _407.entry])];
+      const workerConfig = _optionalChain([configService, 'access', _414 => _414.weappViteConfig, 'optionalAccess', _415 => _415.worker]);
+      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _416 => _416.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _417 => _417.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;
@@ -24406,7 +24748,7 @@ async function transformWxsFile(state, wxsPath) {
     const { result, importees } = transformWxsCode(rawCode, {
       filename: wxsPath
     });
-    if (typeof _optionalChain([result, 'optionalAccess', _408 => _408.code]) === "string") {
+    if (typeof _optionalChain([result, 'optionalAccess', _418 => _418.code]) === "string") {
       code = result.code;
     }
     const dirname5 = _pathe2.default.dirname(wxsPath);
@@ -24483,15 +24825,25 @@ function wxs(ctx) {
 
 // src/plugins/index.ts
 var RUNTIME_PLUGINS_SYMBOL = Symbol.for("weapp-runtime:plugins");
+var WEAPP_VITE_CONTEXT_PLUGIN_NAME = "weapp-vite:context";
+function createContextPlugin(ctx) {
+  return {
+    name: WEAPP_VITE_CONTEXT_PLUGIN_NAME,
+    enforce: "pre",
+    api: {
+      ctx
+    }
+  };
+}
 function attachRuntimePlugins(ctx, plugins) {
   const runtimePlugins = ctx[RUNTIME_PLUGINS_SYMBOL];
-  if (!_optionalChain([runtimePlugins, 'optionalAccess', _409 => _409.length])) {
+  if (!_optionalChain([runtimePlugins, 'optionalAccess', _419 => _419.length])) {
     return plugins;
   }
   return [...runtimePlugins, ...plugins];
 }
 function applyInspect(ctx, plugins) {
-  const inspectOptions = _optionalChain([ctx, 'access', _410 => _410.configService, 'access', _411 => _411.weappViteConfig, 'optionalAccess', _412 => _412.debug, 'optionalAccess', _413 => _413.inspect]);
+  const inspectOptions = _optionalChain([ctx, 'access', _420 => _420.configService, 'access', _421 => _421.weappViteConfig, 'optionalAccess', _422 => _422.debug, 'optionalAccess', _423 => _423.inspect]);
   if (!inspectOptions) {
     return plugins;
   }
@@ -24504,7 +24856,7 @@ function flatten(groups) {
   }, []);
 }
 function vitePluginWeapp(ctx, subPackageMeta) {
-  const groups = [preflight(ctx)];
+  const groups = [[createContextPlugin(ctx)], preflight(ctx)];
   if (!subPackageMeta) {
     groups.push(asset(ctx), autoRoutes(ctx), autoImport(ctx));
   }
@@ -24516,7 +24868,7 @@ function vitePluginWeapp(ctx, subPackageMeta) {
   return applyInspect(ctx, assembled);
 }
 function vitePluginWeappWorkers(ctx) {
-  const groups = [preflight(ctx), workers(ctx)];
+  const groups = [[createContextPlugin(ctx)], preflight(ctx), workers(ctx)];
   const assembled = attachRuntimePlugins(ctx, flatten(groups));
   return applyInspect(ctx, assembled);
 }
@@ -24582,7 +24934,7 @@ function createMergeFactories(options) {
     const currentOptions = getOptions2();
     applyRuntimePlatform("miniprogram");
     const external = [];
-    if (_optionalChain([currentOptions, 'access', _414 => _414.packageJson, 'optionalAccess', _415 => _415.dependencies])) {
+    if (_optionalChain([currentOptions, 'access', _424 => _424.packageJson, 'optionalAccess', _425 => _425.dependencies])) {
       external.push(
         ...Object.keys(currentOptions.packageJson.dependencies).map((pkg) => {
           return new RegExp(`^${pkg.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}(\\/|$)`);
@@ -24597,7 +24949,7 @@ function createMergeFactories(options) {
       const watchInclude = [
         _pathe2.default.join(currentOptions.cwd, currentOptions.srcRoot, "**")
       ];
-      const pluginRootConfig = _optionalChain([currentOptions, 'access', _416 => _416.config, 'access', _417 => _417.weapp, 'optionalAccess', _418 => _418.pluginRoot]);
+      const pluginRootConfig = _optionalChain([currentOptions, 'access', _426 => _426.config, 'access', _427 => _427.weapp, 'optionalAccess', _428 => _428.pluginRoot]);
       if (pluginRootConfig) {
         const absolutePluginRoot = _pathe2.default.resolve(currentOptions.cwd, pluginRootConfig);
         const relativeToSrc = _pathe2.default.relative(
@@ -24657,7 +25009,7 @@ function createMergeFactories(options) {
     );
     inlineConfig.logLevel = "info";
     injectBuiltinAliases(inlineConfig);
-    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _419 => _419.subPackage, 'access', _420 => _420.root]);
+    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _429 => _429.subPackage, 'access', _430 => _430.root]);
     setOptions({
       ...currentOptions,
       currentSubPackageRoot: currentRoot
@@ -24668,7 +25020,7 @@ function createMergeFactories(options) {
     ensureConfigService();
     const currentOptions = getOptions2();
     const web = currentOptions.weappWeb;
-    if (!_optionalChain([web, 'optionalAccess', _421 => _421.enabled])) {
+    if (!_optionalChain([web, 'optionalAccess', _431 => _431.enabled])) {
       return void 0;
     }
     applyRuntimePlatform("web");
@@ -24759,7 +25111,7 @@ function createConfigService(ctx) {
     defineEnv[key] = value;
   }
   function getDefineImportMetaEnv() {
-    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _422 => _422.platform]), () => ( DEFAULT_MP_PLATFORM));
+    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _432 => _432.platform]), () => ( DEFAULT_MP_PLATFORM));
     const resolvedPlatform = _nullishCoalesce(defineEnv.PLATFORM, () => ( mpPlatform));
     const env = {
       PLATFORM: resolvedPlatform,
@@ -24775,7 +25127,7 @@ function createConfigService(ctx) {
   }
   function applyRuntimePlatform(runtime) {
     const isWeb = runtime === "web";
-    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _423 => _423.platform]), () => ( DEFAULT_MP_PLATFORM));
+    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _433 => _433.platform]), () => ( DEFAULT_MP_PLATFORM));
     const resolvedPlatform = isWeb ? "web" : mpPlatform;
     setDefineEnv("PLATFORM", resolvedPlatform);
     setDefineEnv("IS_WEB", isWeb);
@@ -24886,10 +25238,10 @@ function createConfigService(ctx) {
       return options.srcRoot;
     },
     get pluginRoot() {
-      return _optionalChain([options, 'access', _424 => _424.config, 'access', _425 => _425.weapp, 'optionalAccess', _426 => _426.pluginRoot]);
+      return _optionalChain([options, 'access', _434 => _434.config, 'access', _435 => _435.weapp, 'optionalAccess', _436 => _436.pluginRoot]);
     },
     get absolutePluginRoot() {
-      if (_optionalChain([options, 'access', _427 => _427.config, 'access', _428 => _428.weapp, 'optionalAccess', _429 => _429.pluginRoot])) {
+      if (_optionalChain([options, 'access', _437 => _437.config, 'access', _438 => _438.weapp, 'optionalAccess', _439 => _439.pluginRoot])) {
         return _pathe2.default.resolve(options.cwd, options.config.weapp.pluginRoot);
       }
     },
@@ -24919,7 +25271,7 @@ function createConfigService(ctx) {
     },
     relativeAbsoluteSrcRoot(p) {
       const absoluteSrcRoot = _pathe2.default.resolve(options.cwd, options.srcRoot);
-      const pluginRootConfig = _optionalChain([options, 'access', _430 => _430.config, 'access', _431 => _431.weapp, 'optionalAccess', _432 => _432.pluginRoot]);
+      const pluginRootConfig = _optionalChain([options, 'access', _440 => _440.config, 'access', _441 => _441.weapp, 'optionalAccess', _442 => _442.pluginRoot]);
       if (pluginRootConfig) {
         const absolutePluginRoot = _pathe2.default.resolve(options.cwd, pluginRootConfig);
         const relativeToPlugin = _pathe2.default.relative(absolutePluginRoot, p);
@@ -24971,10 +25323,10 @@ function createJsonService(ctx) {
       }
       let resultJson;
       if (/app\.json(?:\.[jt]s)?$/.test(filepath)) {
-        await _optionalChain([ctx, 'access', _433 => _433.autoRoutesService, 'optionalAccess', _434 => _434.ensureFresh, 'call', _435 => _435()]);
+        await _optionalChain([ctx, 'access', _443 => _443.autoRoutesService, 'optionalAccess', _444 => _444.ensureFresh, 'call', _445 => _445()]);
       }
       if (/\.json\.[jt]s$/.test(filepath)) {
-        const routesReference = _optionalChain([ctx, 'access', _436 => _436.autoRoutesService, 'optionalAccess', _437 => _437.getReference, 'call', _438 => _438()]);
+        const routesReference = _optionalChain([ctx, 'access', _446 => _446.autoRoutesService, 'optionalAccess', _447 => _447.getReference, 'call', _448 => _448()]);
         const fallbackRoutes = _nullishCoalesce(routesReference, () => ( { pages: [], entries: [], subPackages: [] }));
         const routesModule = {
           routes: fallbackRoutes,
@@ -25023,7 +25375,7 @@ function createJsonService(ctx) {
       return resultJson;
     } catch (error) {
       logger_default.error(`\u6B8B\u7834\u7684JSON\u6587\u4EF6: ${filepath}`);
-      _optionalChain([debug, 'optionalCall', _439 => _439(error)]);
+      _optionalChain([debug, 'optionalCall', _449 => _449(error)]);
     }
   }
   function resolve8(entry) {
@@ -25078,7 +25430,7 @@ function createNpmService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before writing npm cache");
     }
-    if (_optionalChain([ctx, 'access', _440 => _440.configService, 'access', _441 => _441.weappViteConfig, 'optionalAccess', _442 => _442.npm, 'optionalAccess', _443 => _443.cache])) {
+    if (_optionalChain([ctx, 'access', _450 => _450.configService, 'access', _451 => _451.weappViteConfig, 'optionalAccess', _452 => _452.npm, 'optionalAccess', _453 => _453.cache])) {
       await _fsextra2.default.outputJSON(getDependenciesCacheFilePath(root), {
         hash: dependenciesCacheHash()
       });
@@ -25091,7 +25443,7 @@ function createNpmService(ctx) {
     }
   }
   async function checkDependenciesCacheOutdate(root) {
-    if (_optionalChain([ctx, 'access', _444 => _444.configService, 'optionalAccess', _445 => _445.weappViteConfig, 'optionalAccess', _446 => _446.npm, 'optionalAccess', _447 => _447.cache])) {
+    if (_optionalChain([ctx, 'access', _454 => _454.configService, 'optionalAccess', _455 => _455.weappViteConfig, 'optionalAccess', _456 => _456.npm, 'optionalAccess', _457 => _457.cache])) {
       const json = await readDependenciesCache(root);
       if (_shared.isObject.call(void 0, json)) {
         return dependenciesCacheHash() !== json.hash;
@@ -25124,7 +25476,7 @@ function createNpmService(ctx) {
       target: "es6",
       external: []
     });
-    const resolvedOptions = _optionalChain([ctx, 'access', _448 => _448.configService, 'optionalAccess', _449 => _449.weappViteConfig, 'optionalAccess', _450 => _450.npm, 'optionalAccess', _451 => _451.buildOptions, 'optionalCall', _452 => _452(
+    const resolvedOptions = _optionalChain([ctx, 'access', _458 => _458.configService, 'optionalAccess', _459 => _459.weappViteConfig, 'optionalAccess', _460 => _460.npm, 'optionalAccess', _461 => _461.buildOptions, 'optionalCall', _462 => _462(
       mergedOptions,
       { name, entry }
     )]);
@@ -25224,7 +25576,7 @@ function createNpmService(ctx) {
       throw new Error("configService must be initialized before resolving npm relation list");
     }
     let packNpmRelationList = [];
-    if (_optionalChain([ctx, 'access', _453 => _453.configService, 'access', _454 => _454.projectConfig, 'access', _455 => _455.setting, 'optionalAccess', _456 => _456.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
+    if (_optionalChain([ctx, 'access', _463 => _463.configService, 'access', _464 => _464.projectConfig, 'access', _465 => _465.setting, 'optionalAccess', _466 => _466.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
       packNpmRelationList = ctx.configService.projectConfig.setting.packNpmRelationList;
     } else {
       packNpmRelationList = [
@@ -25237,10 +25589,10 @@ function createNpmService(ctx) {
     return packNpmRelationList;
   }
   async function build3(options) {
-    if (!_optionalChain([ctx, 'access', _457 => _457.configService, 'optionalAccess', _458 => _458.weappViteConfig, 'optionalAccess', _459 => _459.npm, 'optionalAccess', _460 => _460.enable])) {
+    if (!_optionalChain([ctx, 'access', _467 => _467.configService, 'optionalAccess', _468 => _468.weappViteConfig, 'optionalAccess', _469 => _469.npm, 'optionalAccess', _470 => _470.enable])) {
       return;
     }
-    _optionalChain([debug, 'optionalCall', _461 => _461("buildNpm start")]);
+    _optionalChain([debug, 'optionalCall', _471 => _471("buildNpm start")]);
     const packNpmRelationList = getPackNpmRelationList();
     const [mainRelation, ...subRelations] = packNpmRelationList;
     const packageJsonPath = _pathe2.default.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
@@ -25315,7 +25667,7 @@ function createNpmService(ctx) {
         }
       }
     }
-    _optionalChain([debug, 'optionalCall', _462 => _462("buildNpm end")]);
+    _optionalChain([debug, 'optionalCall', _472 => _472("buildNpm end")]);
   }
   return {
     getDependenciesCacheFilePath,
@@ -25359,7 +25711,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', _463 => _463.captureStackTrace, 'optionalCall', _464 => _464(this, _TimeoutError)]);
+    _optionalChain([Error, 'access', _473 => _473.captureStackTrace, 'optionalCall', _474 => _474(this, _TimeoutError)]);
   }
 }, _class16);
 var getAbortedReason = (signal) => _nullishCoalesce(signal.reason, () => ( new DOMException("This operation was aborted.", "AbortError")));
@@ -25377,7 +25729,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', _465 => _465.aborted])) {
+    if (_optionalChain([signal, 'optionalAccess', _475 => _475.aborted])) {
       reject(getAbortedReason(signal));
       return;
     }
@@ -25475,7 +25827,7 @@ var PriorityQueue = class {
   }
   dequeue() {
     const item = this.#queue.shift();
-    return _optionalChain([item, 'optionalAccess', _466 => _466.run]);
+    return _optionalChain([item, 'optionalAccess', _476 => _476.run]);
   }
   filter(options) {
     return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
@@ -25536,10 +25888,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', _467 => _467.intervalCap, 'optionalAccess', _468 => _468.toString, 'call', _469 => _469()]), () => ( ""))}\` (${typeof options.intervalCap})`);
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _477 => _477.intervalCap, 'optionalAccess', _478 => _478.toString, 'call', _479 => _479()]), () => ( ""))}\` (${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', _470 => _470.interval, 'optionalAccess', _471 => _471.toString, 'call', _472 => _472()]), () => ( ""))}\` (${typeof options.interval})`);
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _480 => _480.interval, 'optionalAccess', _481 => _481.toString, 'call', _482 => _482()]), () => ( ""))}\` (${typeof options.interval})`);
     }
     this.#carryoverIntervalCount = _nullishCoalesce(_nullishCoalesce(options.carryoverIntervalCount, () => ( options.carryoverConcurrencyCount)), () => ( false));
     this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
@@ -25746,7 +26098,7 @@ var PQueue = class extends import_index2.default {
         });
         try {
           try {
-            _optionalChain([options, 'access', _473 => _473.signal, 'optionalAccess', _474 => _474.throwIfAborted, 'call', _475 => _475()]);
+            _optionalChain([options, 'access', _483 => _483.signal, 'optionalAccess', _484 => _484.throwIfAborted, 'call', _485 => _485()]);
           } catch (error) {
             if (!this.#isIntervalIgnored) {
               this.#intervalCount--;
@@ -26119,7 +26471,7 @@ var FileCache = class {
       return true;
     }
     const cachedMtime = this.mtimeMap.get(id);
-    const nextSignature = _optionalChain([options, 'optionalAccess', _476 => _476.content]) !== void 0 ? createSignature(options.content) : void 0;
+    const nextSignature = _optionalChain([options, 'optionalAccess', _486 => _486.content]) !== void 0 ? createSignature(options.content) : void 0;
     const updateSignature = () => {
       if (nextSignature !== void 0) {
         this.signatureMap.set(id, nextSignature);
@@ -26354,7 +26706,7 @@ function coerceStyleConfig(entry) {
   if (!entry || typeof entry !== "object") {
     return void 0;
   }
-  const source = _optionalChain([entry, 'access', _477 => _477.source, 'optionalAccess', _478 => _478.toString, 'call', _479 => _479(), 'access', _480 => _480.trim, 'call', _481 => _481()]);
+  const source = _optionalChain([entry, 'access', _487 => _487.source, 'optionalAccess', _488 => _488.toString, 'call', _489 => _489(), 'access', _490 => _490.trim, 'call', _491 => _491()]);
   if (!source) {
     return void 0;
   }
@@ -26530,7 +26882,7 @@ function normalizeSubPackageStyleEntries(styles, subPackage, configService) {
   if (!service) {
     return void 0;
   }
-  const root = _optionalChain([subPackage, 'access', _482 => _482.root, 'optionalAccess', _483 => _483.trim, 'call', _484 => _484()]);
+  const root = _optionalChain([subPackage, 'access', _492 => _492.root, 'optionalAccess', _493 => _493.trim, 'call', _494 => _494()]);
   if (!root) {
     return void 0;
   }
@@ -26638,7 +26990,7 @@ function createScanService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning subpackages");
     }
-    const json = _optionalChain([scanState, 'access', _485 => _485.appEntry, 'optionalAccess', _486 => _486.json]);
+    const json = _optionalChain([scanState, 'access', _495 => _495.appEntry, 'optionalAccess', _496 => _496.json]);
     if (scanState.isDirty || subPackageMap.size === 0) {
       subPackageMap.clear();
       independentSubPackageMap.clear();
@@ -26656,15 +27008,15 @@ function createScanService(ctx) {
             subPackage,
             entries: resolveSubPackageEntries(subPackage)
           };
-          const subPackageConfig = _optionalChain([ctx, 'access', _487 => _487.configService, 'access', _488 => _488.weappViteConfig, 'optionalAccess', _489 => _489.subPackages, 'optionalAccess', _490 => _490[subPackage.root]]);
-          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _491 => _491.dependencies]);
-          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _492 => _492.inlineConfig]);
+          const subPackageConfig = _optionalChain([ctx, 'access', _497 => _497.configService, 'access', _498 => _498.weappViteConfig, 'optionalAccess', _499 => _499.subPackages, 'optionalAccess', _500 => _500[subPackage.root]]);
+          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _501 => _501.dependencies]);
+          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _502 => _502.inlineConfig]);
           meta.styleEntries = normalizeSubPackageStyleEntries(
-            _optionalChain([subPackageConfig, 'optionalAccess', _493 => _493.styles]),
+            _optionalChain([subPackageConfig, 'optionalAccess', _503 => _503.styles]),
             subPackage,
             ctx.configService
           );
-          meta.watchSharedStyles = _nullishCoalesce(_optionalChain([subPackageConfig, 'optionalAccess', _494 => _494.watchSharedStyles]), () => ( true));
+          meta.watchSharedStyles = _nullishCoalesce(_optionalChain([subPackageConfig, 'optionalAccess', _504 => _504.watchSharedStyles]), () => ( true));
           metas.push(meta);
           if (subPackage.root) {
             subPackageMap.set(subPackage.root, meta);
@@ -26720,11 +27072,11 @@ function createScanService(ctx) {
     loadSubPackages,
     isMainPackageFileName,
     get workersOptions() {
-      return _optionalChain([scanState, 'access', _495 => _495.appEntry, 'optionalAccess', _496 => _496.json, 'optionalAccess', _497 => _497.workers]);
+      return _optionalChain([scanState, 'access', _505 => _505.appEntry, 'optionalAccess', _506 => _506.json, 'optionalAccess', _507 => _507.workers]);
     },
     get workersDir() {
-      const workersOptions = _optionalChain([scanState, 'access', _498 => _498.appEntry, 'optionalAccess', _499 => _499.json, 'optionalAccess', _500 => _500.workers]);
-      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _501 => _501.path]) : workersOptions;
+      const workersOptions = _optionalChain([scanState, 'access', _508 => _508.appEntry, 'optionalAccess', _509 => _509.json, 'optionalAccess', _510 => _510.workers]);
+      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _511 => _511.path]) : workersOptions;
     },
     markDirty() {
       scanState.isDirty = true;
@@ -26771,7 +27123,7 @@ function createWatcherService(ctx) {
     },
     setRollupWatcher(watcher, root = "/") {
       const oldWatcher = rollupWatcherMap.get(root);
-      _optionalChain([oldWatcher, 'optionalAccess', _502 => _502.close, 'call', _503 => _503()]);
+      _optionalChain([oldWatcher, 'optionalAccess', _512 => _512.close, 'call', _513 => _513()]);
       rollupWatcherMap.set(root, watcher);
     },
     closeAll() {
@@ -26784,7 +27136,7 @@ function createWatcherService(ctx) {
         });
       });
       sidecarWatcherMap.clear();
-      void _optionalChain([ctx, 'access', _504 => _504.webService, 'optionalAccess', _505 => _505.close, 'call', _506 => _506(), 'access', _507 => _507.catch, 'call', _508 => _508(() => {
+      void _optionalChain([ctx, 'access', _514 => _514.webService, 'optionalAccess', _515 => _515.close, 'call', _516 => _516(), 'access', _517 => _517.catch, 'call', _518 => _518(() => {
       })]);
     },
     close(root = "/") {
@@ -26800,7 +27152,7 @@ function createWatcherService(ctx) {
         sidecarWatcherMap.delete(root);
       }
       if (rollupWatcherMap.size === 0 && sidecarWatcherMap.size === 0) {
-        void _optionalChain([ctx, 'access', _509 => _509.webService, 'optionalAccess', _510 => _510.close, 'call', _511 => _511(), 'access', _512 => _512.catch, 'call', _513 => _513(() => {
+        void _optionalChain([ctx, 'access', _519 => _519.webService, 'optionalAccess', _520 => _520.close, 'call', _521 => _521(), 'access', _522 => _522.catch, 'call', _523 => _523(() => {
         })]);
       }
     }
@@ -26813,7 +27165,7 @@ function createWatcherServicePlugin(ctx) {
     name: "weapp-runtime:watcher-service",
     closeBundle() {
       const configService = ctx.configService;
-      const isWatchMode = _optionalChain([configService, 'optionalAccess', _514 => _514.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _515 => _515.inlineConfig, 'optionalAccess', _516 => _516.build, 'optionalAccess', _517 => _517.watch]));
+      const isWatchMode = _optionalChain([configService, 'optionalAccess', _524 => _524.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _525 => _525.inlineConfig, 'optionalAccess', _526 => _526.build, 'optionalAccess', _527 => _527.watch]));
       if (!isWatchMode) {
         service.closeAll();
       }
@@ -26830,10 +27182,10 @@ function createWebService(ctx) {
   }
   let devServer;
   function isEnabled() {
-    return Boolean(_optionalChain([ctx, 'access', _518 => _518.configService, 'optionalAccess', _519 => _519.weappWebConfig, 'optionalAccess', _520 => _520.enabled]));
+    return Boolean(_optionalChain([ctx, 'access', _528 => _528.configService, 'optionalAccess', _529 => _529.weappWebConfig, 'optionalAccess', _530 => _530.enabled]));
   }
   async function startDevServer() {
-    if (!_optionalChain([ctx, 'access', _521 => _521.configService, 'optionalAccess', _522 => _522.isDev])) {
+    if (!_optionalChain([ctx, 'access', _531 => _531.configService, 'optionalAccess', _532 => _532.isDev])) {
       return void 0;
     }
     if (!isEnabled()) {
@@ -26842,7 +27194,7 @@ function createWebService(ctx) {
     if (devServer) {
       return devServer;
     }
-    const inlineConfig = _optionalChain([ctx, 'access', _523 => _523.configService, 'optionalAccess', _524 => _524.mergeWeb, 'call', _525 => _525()]);
+    const inlineConfig = _optionalChain([ctx, 'access', _533 => _533.configService, 'optionalAccess', _534 => _534.mergeWeb, 'call', _535 => _535()]);
     if (!inlineConfig) {
       return void 0;
     }
@@ -26855,7 +27207,7 @@ function createWebService(ctx) {
     if (!isEnabled()) {
       return void 0;
     }
-    const inlineConfig = _optionalChain([ctx, 'access', _526 => _526.configService, 'optionalAccess', _527 => _527.mergeWeb, 'call', _528 => _528()]);
+    const inlineConfig = _optionalChain([ctx, 'access', _536 => _536.configService, 'optionalAccess', _537 => _537.mergeWeb, 'call', _538 => _538()]);
     if (!inlineConfig) {
       return void 0;
     }
@@ -26885,7 +27237,7 @@ function createWebServicePlugin(ctx) {
   return {
     name: "weapp-runtime:web-service",
     async closeBundle() {
-      if (!_optionalChain([ctx, 'access', _529 => _529.configService, 'optionalAccess', _530 => _530.isDev])) {
+      if (!_optionalChain([ctx, 'access', _539 => _539.configService, 'optionalAccess', _540 => _540.isDev])) {
         await service.close();
       }
     }
@@ -29534,7 +29886,7 @@ function createWxmlService(ctx) {
     return set3;
   }
   function clearAll() {
-    const currentRoot = _optionalChain([ctx, 'access', _531 => _531.configService, 'optionalAccess', _532 => _532.currentSubPackageRoot]);
+    const currentRoot = _optionalChain([ctx, 'access', _541 => _541.configService, 'optionalAccess', _542 => _542.currentSubPackageRoot]);
     if (!currentRoot) {
       depsMap.clear();
       tokenMap.clear();
@@ -29593,7 +29945,7 @@ function createWxmlService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning wxml");
     }
-    const wxmlConfig = _nullishCoalesce(_optionalChain([ctx, 'access', _533 => _533.configService, 'access', _534 => _534.weappViteConfig, 'optionalAccess', _535 => _535.wxml]), () => ( _optionalChain([ctx, 'access', _536 => _536.configService, 'access', _537 => _537.weappViteConfig, 'optionalAccess', _538 => _538.enhance, 'optionalAccess', _539 => _539.wxml])));
+    const wxmlConfig = _nullishCoalesce(_optionalChain([ctx, 'access', _543 => _543.configService, 'access', _544 => _544.weappViteConfig, 'optionalAccess', _545 => _545.wxml]), () => ( _optionalChain([ctx, 'access', _546 => _546.configService, 'access', _547 => _547.weappViteConfig, 'optionalAccess', _548 => _548.enhance, 'optionalAccess', _549 => _549.wxml])));
     return scanWxml(wxml, {
       platform: ctx.configService.platform,
       ...wxmlConfig === true ? {} : wxmlConfig
@@ -29725,7 +30077,9 @@ function resetCompilerContext(key) {
 
 
 
-exports.logger_default = logger_default; exports.VERSION = VERSION; exports.checkRuntime = checkRuntime; exports.resolveWeappConfigFile = resolveWeappConfigFile; exports.DEFAULT_MP_PLATFORM = DEFAULT_MP_PLATFORM; exports.normalizeMiniPlatform = normalizeMiniPlatform; exports.resolveMiniPlatform = resolveMiniPlatform; exports.setActiveCompilerContextKey = setActiveCompilerContextKey; exports.getCompilerContext = getCompilerContext; exports.resetCompilerContext = resetCompilerContext;
+
+
+exports.logger_default = logger_default; exports.VERSION = VERSION; exports.checkRuntime = checkRuntime; exports.resolveWeappConfigFile = resolveWeappConfigFile; exports.SHARED_CHUNK_VIRTUAL_PREFIX = SHARED_CHUNK_VIRTUAL_PREFIX; exports.createSharedBuildConfig = createSharedBuildConfig; exports.DEFAULT_MP_PLATFORM = DEFAULT_MP_PLATFORM; exports.normalizeMiniPlatform = normalizeMiniPlatform; exports.resolveMiniPlatform = resolveMiniPlatform; exports.setActiveCompilerContextKey = setActiveCompilerContextKey; exports.getCompilerContext = getCompilerContext; exports.resetCompilerContext = resetCompilerContext;
 /*! Bundled license information:
 
 chokidar/esm/index.js: