weapp-vite 5.6.3 → 5.7.1

package/dist/{chunk-LE4PAGI5.mjs → chunk-O4FBXXL3.mjs}

@@ -649,11 +649,6 @@ var require_eventemitter3 = __commonJS({
   }
 });
 
-// src/logger.ts
-init_esm_shims();
-import logger from "@weapp-core/logger";
-var logger_default = logger;
-
 // src/constants.ts
 init_esm_shims();
 var VERSION = "__VERSION__";
@@ -672,6 +667,13 @@ var templateExtensions = ["wxml", "html"];
 init_esm_shims();
 var import_gte = __toESM(require_gte(), 1);
 import process2 from "process";
+
+// src/logger.ts
+init_esm_shims();
+import logger from "@weapp-core/logger";
+var logger_default = logger;
+
+// src/utils/version.ts
 function getRuntime() {
   if (typeof process2 !== "undefined" && process2.versions?.node) {
     return {
@@ -706,55 +708,13 @@ function checkRuntime(minVersions) {
   }
 }
 
-// src/utils/weappConfig.ts
-init_esm_shims();
-import fs from "fs-extra";
-import path from "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 = path.resolve(directory, filename);
-    if (await fs.pathExists(candidatePath)) {
-      return candidatePath;
-    }
-  }
-  return void 0;
-}
-async function resolveWeappConfigFile(options) {
-  const { root, specified } = options;
-  if (specified) {
-    const resolvedSpecified = path.isAbsolute(specified) ? specified : path.resolve(root, specified);
-    const specifiedBaseName = path.basename(resolvedSpecified);
-    if (WEAPP_VITE_CONFIG_SET.has(specifiedBaseName)) {
-      if (await fs.pathExists(resolvedSpecified)) {
-        return resolvedSpecified;
-      }
-      return void 0;
-    }
-    const fromSpecifiedDirectory = await findWeappConfigInDirectory(path.dirname(resolvedSpecified));
-    if (fromSpecifiedDirectory) {
-      return fromSpecifiedDirectory;
-    }
-  }
-  return findWeappConfigInDirectory(root);
-}
-
 // src/utils/index.ts
 init_esm_shims();
 
 // src/utils/file.ts
 init_esm_shims();
-import fs2 from "fs-extra";
-import path2 from "pathe";
+import fs from "fs-extra";
+import path from "pathe";
 function isJsOrTs(name) {
   if (typeof name === "string") {
     return /\.[jt]s$/.test(name);
@@ -775,13 +735,13 @@ function changeFileExtension(filePath, extension) {
     return "";
   }
   extension = extension ? extension.startsWith(".") ? extension : `.${extension}` : "";
-  const basename4 = path2.basename(filePath, path2.extname(filePath));
-  return path2.join(path2.dirname(filePath), basename4 + extension);
+  const basename4 = path.basename(filePath, path.extname(filePath));
+  return path.join(path.dirname(filePath), basename4 + extension);
 }
 async function findVueEntry(filepath) {
   for (const ext2 of vueExtensions) {
     const p = changeFileExtension(filepath, ext2);
-    if (await fs2.exists(p)) {
+    if (await fs.exists(p)) {
       return p;
     }
   }
@@ -791,7 +751,7 @@ async function findJsEntry(filepath) {
     return changeFileExtension(filepath, ext2);
   });
   for (const p of predictions) {
-    if (await fs2.exists(p)) {
+    if (await fs.exists(p)) {
       return {
         path: p,
         predictions
@@ -807,7 +767,7 @@ async function findJsonEntry(filepath) {
     return changeFileExtension(filepath, ext2);
   });
   for (const p of predictions) {
-    if (await fs2.exists(p)) {
+    if (await fs.exists(p)) {
       return {
         predictions,
         path: p
@@ -823,7 +783,7 @@ async function findCssEntry(filepath) {
     return changeFileExtension(filepath, ext2);
   });
   for (const p of predictions) {
-    if (await fs2.exists(p)) {
+    if (await fs.exists(p)) {
       return {
         predictions,
         path: p
@@ -839,7 +799,7 @@ async function findTemplateEntry(filepath) {
     return changeFileExtension(filepath, ext2);
   });
   for (const p of predictions) {
-    if (await fs2.exists(p)) {
+    if (await fs.exists(p)) {
       return {
         predictions,
         path: p
@@ -856,9 +816,9 @@ function isTemplate(filepath) {
 async function touch(filename) {
   const time = /* @__PURE__ */ new Date();
   try {
-    await fs2.utimes(filename, time, time);
+    await fs.utimes(filename, time, time);
   } catch {
-    await fs2.close(await fs2.open(filename, "w"));
+    await fs.close(await fs.open(filename, "w"));
   }
 }
 
@@ -866,7 +826,7 @@ async function touch(filename) {
 init_esm_shims();
 import { get, isObject, set } from "@weapp-core/shared";
 import { parse as parseJson, stringify } from "comment-json";
-import path3 from "pathe";
+import path2 from "pathe";
 function jsonFileRemoveJsExtension(fileName) {
   return fileName.replace(/\.[jt]s$/, "");
 }
@@ -911,7 +871,7 @@ function resolveImportee(importee, jsonPath, aliasEntries) {
       return importee;
     }
     const updatedId = importee.replace(matchedEntry.find, matchedEntry.replacement);
-    return path3.relative(path3.dirname(jsonPath), updatedId);
+    return path2.relative(path2.dirname(jsonPath), updatedId);
   }
   return importee;
 }
@@ -954,16 +914,16 @@ import crypto from "crypto";
 
 // src/utils/projectConfig.ts
 init_esm_shims();
-import fs3 from "fs-extra";
-import path4 from "pathe";
+import fs2 from "fs-extra";
+import path3 from "pathe";
 async function getProjectConfig(root, options) {
-  const baseJsonPath = path4.resolve(root, "project.config.json");
-  const privateJsonPath = path4.resolve(root, "project.private.config.json");
+  const baseJsonPath = path3.resolve(root, "project.config.json");
+  const privateJsonPath = path3.resolve(root, "project.private.config.json");
   let baseJson = {};
   let privateJson = {};
-  if (await fs3.exists(baseJsonPath)) {
+  if (await fs2.exists(baseJsonPath)) {
     try {
-      baseJson = await fs3.readJson(baseJsonPath) || {};
+      baseJson = await fs2.readJson(baseJsonPath) || {};
     } catch {
       throw new Error(`\u89E3\u6790 json \u683C\u5F0F\u5931\u8D25, project.config.json \u4E3A\u975E\u6CD5\u7684 json \u683C\u5F0F`);
     }
@@ -971,9 +931,9 @@ async function getProjectConfig(root, options) {
     throw new Error(`\u5728 ${root} \u76EE\u5F55\u4E0B\u627E\u4E0D\u5230 project.config.json`);
   }
   if (!options?.ignorePrivate) {
-    if (await fs3.exists(privateJsonPath)) {
+    if (await fs2.exists(privateJsonPath)) {
       try {
-        privateJson = await fs3.readJson(privateJsonPath) || {};
+        privateJson = await fs2.readJson(privateJsonPath) || {};
       } catch {
         throw new Error(`\u89E3\u6790 json \u683C\u5F0F\u5931\u8D25, project.private.config.json \u4E3A\u975E\u6CD5\u7684 json \u683C\u5F0F`);
       }
@@ -1014,121 +974,46 @@ function regExpTest(arr, str, options) {
   return false;
 }
 
-// src/platform.ts
-init_esm_shims();
-
-// src/platforms/adapters.ts
+// src/utils/weappConfig.ts
 init_esm_shims();
-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"
-    }
-  }
+import fs3 from "fs-extra";
+import path4 from "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"
 ];
-
-// 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_SET = new Set(WEAPP_VITE_CONFIG_CANDIDATES);
+async function findWeappConfigInDirectory(directory) {
+  for (const filename of WEAPP_VITE_CONFIG_CANDIDATES) {
+    const candidatePath = path4.resolve(directory, filename);
+    if (await fs3.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 = path4.isAbsolute(specified) ? specified : path4.resolve(root, specified);
+    const specifiedBaseName = path4.basename(resolvedSpecified);
+    if (WEAPP_VITE_CONFIG_SET.has(specifiedBaseName)) {
+      if (await fs3.pathExists(resolvedSpecified)) {
+        return resolvedSpecified;
+      }
+      return void 0;
+    }
+    const fromSpecifiedDirectory = await findWeappConfigInDirectory(path4.dirname(resolvedSpecified));
+    if (fromSpecifiedDirectory) {
+      return fromSpecifiedDirectory;
+    }
   }
-  return adapter;
+  return findWeappConfigInDirectory(root);
 }
 
 // src/context/getInstance.ts
@@ -11894,31 +11779,170 @@ rimraf.rimraf = rimraf;
 // src/runtime/buildPlugin.ts
 import { build } from "vite";
 
+// src/runtime/independentError.ts
+init_esm_shims();
+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 "";
+  }
+  return ` (${parts.join(", ")})`;
+}
+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(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 {
+  }
+  return new Error(fallback, { cause });
+}
+
+// src/runtime/sharedBuildConfig.ts
+init_esm_shims();
+import picomatch from "picomatch";
+
 // src/runtime/advancedChunks.ts
 init_esm_shims();
 
 // src/runtime/chunkStrategy.ts
 init_esm_shims();
+import { Buffer as Buffer2 } from "buffer";
 import { posix as path10 } from "pathe";
 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
+    strategy,
+    forceDuplicateTester
   } = options;
   const moduleInfo = ctx.getModuleInfo(id);
   if (!moduleInfo?.importers || moduleInfo.importers.length <= 1) {
     return void 0;
   }
-  const summary = summarizeImportPrefixes({
+  const { summary, ignoredMainImporters } = summarizeImportPrefixes({
+    ctx,
     importers: moduleInfo.importers,
     relativeAbsoluteSrcRoot,
-    subPackageRoots: Array.from(subPackageRoots)
+    subPackageRoots: Array.from(subPackageRoots),
+    forceDuplicateTester
   });
   const keys = Object.keys(summary);
   if (keys.length === 0) {
@@ -11932,19 +11956,145 @@ function resolveSharedChunkName(options) {
   if (strategy === "duplicate" && !hasMainImporter) {
     const combination = keys.filter(Boolean).sort().join("+");
     const combinationSegment = combination ? `${combination}/` : "";
-    return `${SHARED_CHUNK_VIRTUAL_PREFIX}/${combinationSegment}common`;
+    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 { importers, relativeAbsoluteSrcRoot, subPackageRoots } = 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 relPath = relativeAbsoluteSrcRoot(importer);
-    const prefix = resolveSubPackagePrefix(relPath, subPackageRoots);
-    summary[prefix] = (summary[prefix] || 0) + 1;
+    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 = moduleInfo?.importers ?? [];
+  const forcedDuplicate = forceDuplicateTester?.(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;
   }
-  return summary;
+  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) {
@@ -12000,6 +12150,7 @@ 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);
@@ -12016,6 +12167,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",
@@ -12038,20 +12190,42 @@ 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 = {};
+    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" ? Buffer2.byteLength(originalCode, "utf8") : void 0;
+    const redundantBytes = typeof chunkBytes === "number" ? chunkBytes * Math.max(duplicates.length - 1, 0) : void 0;
     options.onDuplicate?.({
       sharedFileName: originalSharedFileName,
-      duplicates
+      duplicates,
+      ignoredMainImporters: diagnostics?.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 output?.type === "chunk" && fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`);
 }
@@ -12064,6 +12238,24 @@ function findChunkImporters(bundle, target) {
     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 = metadata.importedScripts ?? metadata.importedScriptsByUrl;
+      if (hasInCollection(importedScripts, target)) {
+        importers.add(fileName);
+        continue;
+      }
+    }
+    const potentialImport = createRelativeImport(fileName, target);
+    if (potentialImport && containsImportSpecifier(chunk.code ?? "", potentialImport)) {
+      importers.add(fileName);
     }
   }
   return Array.from(importers);
@@ -12091,11 +12283,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
+      );
+    }
+    const referencedFiles = importerChunk.referencedFiles;
+    if (Array.isArray(referencedFiles)) {
+      importerChunk.referencedFiles = replaceInArray(
+        referencedFiles,
+        originalFileName,
+        newChunkFile,
+        codeUpdated
+      );
     }
-    importerChunk.imports = replaceInArray(importerChunk.imports, originalFileName, newChunkFile);
-    importerChunk.dynamicImports = replaceInArray(importerChunk.dynamicImports, originalFileName, newChunkFile);
+    updateViteMetadata(importerChunk, originalFileName, newChunkFile, codeUpdated);
   }
 }
 function replaceAll(source, searchValue, replaceValue) {
@@ -12114,185 +12330,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 = path10.relative(path10.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
-init_esm_shims();
-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(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 = path10.relative(path10.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 = picomatch(pattern, { dot: true });
+      return (value) => matcher(value);
     }
-  } catch {
+    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 = configService.weappViteConfig?.chunks?.sharedStrategy ?? DEFAULT_SHARED_CHUNK_STRATEGY;
+  const forceDuplicatePatterns = configService.weappViteConfig?.chunks?.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) {
@@ -12380,40 +12594,16 @@ function createBuildService(ctx) {
       configService.mergeWorkers()
     );
   }
-  function sharedBuildConfig() {
-    const nodeModulesDeps = [REG_NODE_MODULES_DIR];
-    const commonjsHelpersDeps = [/commonjsHelpers\.js$/];
-    const sharedStrategy = configService.weappViteConfig?.chunks?.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 (process3.env.NODE_ENV === void 0) {
       process3.env.NODE_ENV = "development";
     }
     debug?.("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 = build(
       buildOptions
     );
@@ -12502,7 +12692,10 @@ function createBuildService(ctx) {
     debug?.("prod build start");
     const { hasWorkersDir } = checkWorkersOptions();
     const bundlerPromise = build(
-      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]);
@@ -20021,6 +20214,123 @@ function isMetadataYarnClassic(metadataPath) {
 // src/runtime/config/createConfigService.ts
 import path32 from "pathe";
 
+// src/platform.ts
+init_esm_shims();
+
+// src/platforms/adapters.ts
+init_esm_shims();
+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
 init_esm_shims();
 import fs10 from "fs-extra";
@@ -20303,7 +20613,9 @@ function getWeappViteConfig() {
     },
     chunks: {
       sharedStrategy: "duplicate",
-      logOptimization: true
+      logOptimization: true,
+      forceDuplicatePatterns: [],
+      duplicateWarningBytes: 512 * 1024
     }
   };
 }
@@ -23730,10 +24042,16 @@ function createCoreLifecyclePlugin(state) {
         const sharedStrategy = configService.weappViteConfig?.chunks?.sharedStrategy ?? DEFAULT_SHARED_CHUNK_STRATEGY;
         const shouldLogChunks = configService.weappViteConfig?.chunks?.logOptimization ?? true;
         const subPackageRoots = Array.from(scanService.subPackageMap.keys()).filter(Boolean);
-        applySharedChunkStrategy.call(this, bundle, {
-          strategy: sharedStrategy,
-          subPackageRoots,
-          onDuplicate: shouldLogChunks ? ({ duplicates }) => {
+        const duplicateWarningBytes = Number(configService.weappViteConfig?.chunks?.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) {
@@ -23744,8 +24062,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 = ignoredMainImporters?.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;
@@ -23772,6 +24096,9 @@ 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 (configService.weappViteConfig?.debug?.watchFiles) {
         const watcherService = ctx.watcherService;
@@ -23847,6 +24174,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;
@@ -23903,7 +24245,7 @@ import path28 from "pathe";
 // src/plugins/css/shared/sharedStyles.ts
 init_esm_shims();
 import path27 from "pathe";
-import picomatch from "picomatch";
+import picomatch2 from "picomatch";
 var SLASH_RE = /\\/g;
 function toPosixPath(value) {
   return value.replace(SLASH_RE, "/");
@@ -23965,10 +24307,10 @@ function getStyleMatcher(entry) {
   const includePatterns = entry.include?.length ? entry.include : ["**/*"];
   const excludePatterns = entry.exclude?.length ? entry.exclude : void 0;
   const matcher = {
-    include: picomatch(includePatterns, { dot: true })
+    include: picomatch2(includePatterns, { dot: true })
   };
   if (excludePatterns?.length) {
-    matcher.exclude = picomatch(excludePatterns, { dot: true });
+    matcher.exclude = picomatch2(excludePatterns, { dot: true });
   }
   styleMatcherCache.set(entry, matcher);
   return matcher;
@@ -24482,6 +24824,16 @@ 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 (!runtimePlugins?.length) {
@@ -24503,7 +24855,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));
   }
@@ -24515,7 +24867,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);
 }
@@ -29718,6 +30070,8 @@ export {
   VERSION,
   checkRuntime,
   resolveWeappConfigFile,
+  SHARED_CHUNK_VIRTUAL_PREFIX,
+  createSharedBuildConfig,
   DEFAULT_MP_PLATFORM,
   normalizeMiniPlatform,
   resolveMiniPlatform,