weapp-tailwindcss 4.11.0-alpha.0 → 4.11.0-alpha.2

package/dist/{chunk-QX2A7SBB.mjs → chunk-66E76FQE.mjs}

@@ -9,10 +9,7 @@ import {
 } from "./chunk-F2CKKG6Q.mjs";
 import {
   processCachedTask
-} from "./chunk-RRHPTTCP.mjs";
-import {
-  setupPatchRecorder
-} from "./chunk-EOK3NZVC.mjs";
+} from "./chunk-76S2EME4.mjs";
 import {
   babelParse,
   collectRuntimeClassSet,
@@ -20,20 +17,27 @@ import {
   createDebug,
   generateCode,
   getCompilerContext,
-  getRuntimeClassSetSignature,
   refreshTailwindRuntimeState,
   replaceWxml,
+  setupPatchRecorder,
   toCustomAttributesEntities,
   traverse,
   vitePluginName
-} from "./chunk-FMWKBZWX.mjs";
+} from "./chunk-HADJCWHU.mjs";
+import {
+  findNearestPackageRoot,
+  findTailwindConfig,
+  getRuntimeClassSetSignature,
+  resolveTailwindcssOptions
+} from "./chunk-EW2K6CO5.mjs";
 import {
   resolveUniUtsPlatform
 } from "./chunk-OOHJLO5M.mjs";
 
 // src/bundlers/vite/index.ts
-import path3 from "path";
-import process3 from "process";
+import { existsSync } from "fs";
+import path4 from "path";
+import process4 from "process";
 import postcssHtmlTransform from "@weapp-tailwindcss/postcss/html-transform";
 
 // src/uni-app-x/transform.ts
@@ -369,7 +373,7 @@ function createUniAppXAssetTask(file, originalSource, outDir, options) {
       cache,
       hashKey,
       createHandlerOptions,
-      debug: debug2,
+      debug: debug3,
       jsHandler,
       onUpdate,
       runtimeSet,
@@ -388,7 +392,7 @@ function createUniAppXAssetTask(file, originalSource, outDir, options) {
         originalSource.source = source;
       },
       onCacheHit() {
-        debug2("js cache hit: %s", file);
+        debug3("js cache hit: %s", file);
       },
       async transform() {
         const currentSource = originalSource.source.toString();
@@ -402,7 +406,7 @@ function createUniAppXAssetTask(file, originalSource, outDir, options) {
           }
         }));
         onUpdate(file, currentSource, code);
-        debug2("js handle: %s", file);
+        debug3("js handle: %s", file);
         applyLinkedResults2(linked);
         return {
           result: code
@@ -415,6 +419,8 @@ function createUniAppXAssetTask(file, originalSource, outDir, options) {
 // src/bundlers/vite/generate-bundle.ts
 import path2 from "path";
 import process2 from "process";
+import { logger } from "@weapp-tailwindcss/logger";
+import { splitCode } from "@weapp-tailwindcss/shared/extractors";
 
 // src/bundlers/vite/bundle-entries.ts
 import { Buffer } from "buffer";
@@ -486,6 +492,10 @@ function applyLinkedResults(linked, entries, onLinkedUpdate, onApplied) {
 
 // src/bundlers/vite/runtime-affecting-signature.ts
 import { Parser } from "htmlparser2";
+var CSS_BLOCK_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
+var CSS_AROUND_PUNCTUATION_RE = /\s*([{}:;,>+~()])\s*/g;
+var CSS_TRAILING_DECLARATION_SEMICOLON_RE = /;\}/g;
+var CSS_WHITESPACE_RE = /\s+/g;
 function createHtmlRuntimeAffectingSignature(source) {
   try {
     const parts = [];
@@ -526,14 +536,14 @@ function createJsRuntimeAffectingSignature(source) {
     const parts = [];
     traverse(ast, {
       noScope: true,
-      StringLiteral(path4) {
-        parts.push(`s:${path4.node.value}`);
+      StringLiteral(path5) {
+        parts.push(`s:${path5.node.value}`);
       },
-      TemplateElement(path4) {
-        parts.push(`t:${path4.node.value.raw}`);
+      TemplateElement(path5) {
+        parts.push(`t:${path5.node.value.raw}`);
       },
-      JSXText(path4) {
-        const value = path4.node.value.trim();
+      JSXText(path5) {
+        const value = path5.node.value.trim();
         if (value.length > 0) {
           parts.push(`x:${value}`);
         }
@@ -552,6 +562,9 @@ function createJsRuntimeAffectingSignature(source) {
     return source;
   }
 }
+function createCssRuntimeAffectingSignature(source) {
+  return source.replace(CSS_BLOCK_COMMENT_RE, "").replace(CSS_AROUND_PUNCTUATION_RE, "$1").replace(CSS_TRAILING_DECLARATION_SEMICOLON_RE, "}").replace(CSS_WHITESPACE_RE, " ").trim();
+}
 function createRuntimeAffectingSourceSignature(source, type) {
   if (type === "html") {
     return createHtmlRuntimeAffectingSignature(source);
@@ -559,6 +572,9 @@ function createRuntimeAffectingSourceSignature(source, type) {
   if (type === "js") {
     return createJsRuntimeAffectingSignature(source);
   }
+  if (type === "css") {
+    return createCssRuntimeAffectingSignature(source);
+  }
   return source;
 }
 
@@ -620,6 +636,7 @@ function markProcessFile(type, file, processFiles) {
 }
 function buildBundleSnapshot(bundle, opts, outDir, state, forceAll = false) {
   const sourceHashByFile = /* @__PURE__ */ new Map();
+  const runtimeAffectingSignatureByFile = /* @__PURE__ */ new Map();
   const runtimeAffectingHashByFile = /* @__PURE__ */ new Map();
   const changedByType = createChangedByType();
   const runtimeAffectingChangedByType = createChangedByType();
@@ -634,6 +651,7 @@ function buildBundleSnapshot(bundle, opts, outDir, state, forceAll = false) {
     const hash = opts.cache.computeHash(source);
     sourceHashByFile.set(file, hash);
     const runtimeAffectingSignature = createRuntimeAffectingSourceSignature(source, type);
+    runtimeAffectingSignatureByFile.set(file, runtimeAffectingSignature);
     const runtimeAffectingHash = opts.cache.computeHash(runtimeAffectingSignature);
     runtimeAffectingHashByFile.set(file, runtimeAffectingHash);
     const previousHash = state.sourceHashByFile.get(file);
@@ -682,6 +700,7 @@ function buildBundleSnapshot(bundle, opts, outDir, state, forceAll = false) {
     entries,
     jsEntries,
     sourceHashByFile,
+    runtimeAffectingSignatureByFile,
     runtimeAffectingHashByFile,
     changedByType,
     runtimeAffectingChangedByType,
@@ -703,12 +722,22 @@ function invertLinkedByEntry(linkedByEntry) {
   }
   return dependentsByLinkedFile;
 }
-function updateBundleBuildState(state, snapshot, linkedByEntry) {
+function updateBundleBuildState(state, snapshot, linkedByEntry, options = {}) {
+  const incremental = options.incremental === true;
   state.iteration += 1;
-  state.sourceHashByFile = snapshot.sourceHashByFile;
-  state.runtimeAffectingHashByFile = snapshot.runtimeAffectingHashByFile;
-  state.linkedByEntry = linkedByEntry;
-  state.dependentsByLinkedFile = invertLinkedByEntry(linkedByEntry);
+  state.sourceHashByFile = incremental ? new Map([
+    ...state.sourceHashByFile,
+    ...snapshot.sourceHashByFile
+  ]) : snapshot.sourceHashByFile;
+  state.runtimeAffectingHashByFile = incremental ? new Map([
+    ...state.runtimeAffectingHashByFile,
+    ...snapshot.runtimeAffectingHashByFile
+  ]) : snapshot.runtimeAffectingHashByFile;
+  state.linkedByEntry = incremental ? new Map([
+    ...state.linkedByEntry,
+    ...linkedByEntry
+  ]) : linkedByEntry;
+  state.dependentsByLinkedFile = invertLinkedByEntry(state.linkedByEntry);
 }
 
 // src/bundlers/vite/js-precheck.ts
@@ -813,6 +842,42 @@ function createJsHashSalt(runtimeSignature, linkedImpactSignature) {
 function hasRuntimeAffectingSourceChanges(changedByType) {
   return changedByType.html.size > 0 || changedByType.js.size > 0;
 }
+function canShareCssTransformResult(rawSource) {
+  return !rawSource.includes("@import") && !rawSource.includes("url(");
+}
+function hasOmittedKnownBundleFiles(currentBundleFiles, previousBundleFiles) {
+  const currentFileSet = new Set(currentBundleFiles);
+  for (const file of previousBundleFiles) {
+    if (!currentFileSet.has(file)) {
+      return true;
+    }
+  }
+  return false;
+}
+var MUSTACHE_EXPRESSION_RE = /\{\{[\s\S]*?\}\}/g;
+var QUOTED_LITERAL_RE = /'([^']*)'|"([^"]*)"|`([^`]*)`/g;
+function isArbitraryValueCandidate(candidate) {
+  return candidate.includes("[") && candidate.includes("]");
+}
+function collectUnescapedDynamicCandidates(source) {
+  const matches = /* @__PURE__ */ new Set();
+  for (const expression of source.match(MUSTACHE_EXPRESSION_RE) ?? []) {
+    QUOTED_LITERAL_RE.lastIndex = 0;
+    let quoted = QUOTED_LITERAL_RE.exec(expression);
+    while (quoted !== null) {
+      const literal = quoted[1] ?? quoted[2] ?? quoted[3] ?? "";
+      for (const candidate of splitCode(literal, true)) {
+        const normalized = candidate.trim();
+        if (!normalized || !isArbitraryValueCandidate(normalized)) {
+          continue;
+        }
+        matches.add(normalized);
+      }
+      quoted = QUOTED_LITERAL_RE.exec(expression);
+    }
+  }
+  return [...matches];
+}
 function createGenerateBundleHook(context) {
   const state = createBundleBuildState();
   const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
@@ -820,8 +885,8 @@ function createGenerateBundleHook(context) {
     const {
       opts,
       runtimeState,
-      ensureRuntimeClassSet,
-      debug: debug2,
+      ensureBundleRuntimeClassSet,
+      debug: debug3,
       getResolvedConfig
     } = context;
     const {
@@ -857,7 +922,7 @@ function createGenerateBundleHook(context) {
       return created;
     };
     await runtimeState.patchPromise;
-    debug2("start");
+    debug3("start");
     onStart();
     const metrics = createEmptyMetrics();
     const forceRuntimeRefreshByEnv = process2.env.WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH === "1";
@@ -865,54 +930,69 @@ function createGenerateBundleHook(context) {
     const disableJsPrecheck = process2.env.WEAPP_TW_VITE_DISABLE_JS_PRECHECK === "1";
     const debugCssDiff = process2.env.WEAPP_TW_VITE_DEBUG_CSS_DIFF === "1";
     const resolvedConfig = getResolvedConfig();
+    const bundleFiles = Object.keys(bundle);
+    const buildCommand = resolvedConfig?.command === "build";
+    const useIncrementalMode = !buildCommand || hasOmittedKnownBundleFiles(bundleFiles, state.sourceHashByFile.keys());
     const rootDir = resolvedConfig?.root ? path2.resolve(resolvedConfig.root) : process2.cwd();
     const outDir = resolvedConfig?.build?.outDir ? path2.resolve(rootDir, resolvedConfig.build.outDir) : rootDir;
-    const snapshot = buildBundleSnapshot(bundle, opts, outDir, state, disableDirtyOptimization);
-    const forceRuntimeRefreshBySource = hasRuntimeAffectingSourceChanges(snapshot.runtimeAffectingChangedByType);
-    const forceRuntimeRefresh = forceRuntimeRefreshByEnv || forceRuntimeRefreshBySource;
+    const snapshot = buildBundleSnapshot(bundle, opts, outDir, state, disableDirtyOptimization || !useIncrementalMode);
+    const useBundleRuntimeClassSet = useIncrementalMode || runtimeState.twPatcher.majorVersion === 4;
+    const forceRuntimeRefreshBySource = useIncrementalMode && hasRuntimeAffectingSourceChanges(snapshot.runtimeAffectingChangedByType);
     const processFiles = snapshot.processFiles;
-    debug2(
-      "dirty iteration=%d html=%d[%s] js=%d[%s] css=%d[%s] other=%d[%s]",
-      state.iteration + 1,
-      snapshot.changedByType.html.size,
-      formatDebugFileList(snapshot.changedByType.html),
-      snapshot.changedByType.js.size,
-      formatDebugFileList(snapshot.changedByType.js),
-      snapshot.changedByType.css.size,
-      formatDebugFileList(snapshot.changedByType.css),
-      snapshot.changedByType.other.size,
-      formatDebugFileList(snapshot.changedByType.other)
-    );
-    debug2(
-      "process iteration=%d html=%d[%s] js=%d[%s] css=%d[%s]",
-      state.iteration + 1,
-      processFiles.html.size,
-      formatDebugFileList(processFiles.html),
-      processFiles.js.size,
-      formatDebugFileList(processFiles.js),
-      processFiles.css.size,
-      formatDebugFileList(processFiles.css)
-    );
+    if (useIncrementalMode) {
+      debug3(
+        "dirty iteration=%d html=%d[%s] js=%d[%s] css=%d[%s] other=%d[%s]",
+        state.iteration + 1,
+        snapshot.changedByType.html.size,
+        formatDebugFileList(snapshot.changedByType.html),
+        snapshot.changedByType.js.size,
+        formatDebugFileList(snapshot.changedByType.js),
+        snapshot.changedByType.css.size,
+        formatDebugFileList(snapshot.changedByType.css),
+        snapshot.changedByType.other.size,
+        formatDebugFileList(snapshot.changedByType.other)
+      );
+      debug3(
+        "process iteration=%d html=%d[%s] js=%d[%s] css=%d[%s]",
+        state.iteration + 1,
+        processFiles.html.size,
+        formatDebugFileList(processFiles.html),
+        processFiles.js.size,
+        formatDebugFileList(processFiles.js),
+        processFiles.css.size,
+        formatDebugFileList(processFiles.css)
+      );
+    } else {
+      debug3(
+        "build mode full process html=%d[%s] js=%d[%s] css=%d[%s]",
+        processFiles.html.size,
+        formatDebugFileList(processFiles.html),
+        processFiles.js.size,
+        formatDebugFileList(processFiles.js),
+        processFiles.css.size,
+        formatDebugFileList(processFiles.css)
+      );
+    }
     const jsEntries = snapshot.jsEntries;
     const moduleGraphOptions = createBundleModuleGraphOptions(outDir, jsEntries);
     const runtimeStart = performance.now();
-    const runtime = await ensureRuntimeClassSet(forceRuntimeRefresh);
+    const runtime = useBundleRuntimeClassSet ? await ensureBundleRuntimeClassSet(snapshot, forceRuntimeRefreshByEnv) : await context.ensureRuntimeClassSet(forceRuntimeRefreshByEnv);
     const defaultTemplateHandlerOptions = {
       runtimeSet: runtime
     };
     metrics.runtimeSet = measureElapsed(runtimeStart);
     if (forceRuntimeRefreshBySource) {
-      debug2(
+      debug3(
         "runtimeSet forced refresh due to source changes: html=%d js=%d",
         snapshot.runtimeAffectingChangedByType.html.size,
         snapshot.runtimeAffectingChangedByType.js.size
       );
     }
-    debug2("get runtimeSet, class count: %d", runtime.size);
+    debug3("get runtimeSet, class count: %d", runtime.size);
     const runtimeSignature = getRuntimeClassSetSignature(runtimeState.twPatcher) ?? "runtime:missing";
     const handleLinkedUpdate = (fileName, previous, next) => {
       onUpdate(fileName, previous, next);
-      debug2("js linked handle: %s", fileName);
+      debug3("js linked handle: %s", fileName);
     };
     const pendingLinkedUpdates = [];
     const scheduleLinkedApply = (entry, code) => {
@@ -937,7 +1017,8 @@ function createGenerateBundleHook(context) {
         sourceFilename: absoluteFilename
       }
     });
-    const linkedByEntry = /* @__PURE__ */ new Map();
+    const linkedByEntry = useIncrementalMode ? /* @__PURE__ */ new Map() : void 0;
+    const sharedCssResultCache = /* @__PURE__ */ new Map();
     const tasks = [];
     const jsTaskFactories = [];
     for (const entry of snapshot.entries) {
@@ -959,15 +1040,35 @@ function createGenerateBundleHook(context) {
             },
             onCacheHit() {
               metrics.html.cacheHits++;
-              debug2("html cache hit: %s", file);
+              debug3("html cache hit: %s", file);
             },
             async transform() {
               const start = performance.now();
-              const transformed = await templateHandler(rawSource, defaultTemplateHandlerOptions);
+              let transformed = await templateHandler(rawSource, defaultTemplateHandlerOptions);
+              let unresolvedDynamicCandidates = collectUnescapedDynamicCandidates(transformed);
+              if (unresolvedDynamicCandidates.length > 0) {
+                logger.warn(
+                  "\u68C0\u6D4B\u5230 WXML \u52A8\u6001\u7C7B\u540D\u672A\u5B8C\u6210\u8F6C\u8BD1\uFF0C\u5DF2\u56DE\u9000\u5230\u5B8C\u6574 runtimeSet \u91CD\u8BD5: %s -> %O",
+                  file,
+                  unresolvedDynamicCandidates
+                );
+                const fullRuntimeSet = await context.ensureRuntimeClassSet(true);
+                transformed = await templateHandler(rawSource, {
+                  runtimeSet: fullRuntimeSet
+                });
+                unresolvedDynamicCandidates = collectUnescapedDynamicCandidates(transformed);
+                if (unresolvedDynamicCandidates.length > 0) {
+                  logger.warn(
+                    "WXML \u52A8\u6001\u7C7B\u540D\u5728\u5B8C\u6574 runtimeSet \u91CD\u8BD5\u540E\u4ECD\u672A\u5B8C\u6210\u8F6C\u8BD1: %s -> %O",
+                    file,
+                    unresolvedDynamicCandidates
+                  );
+                }
+              }
               metrics.html.elapsed += measureElapsed(start);
               metrics.html.transformed++;
               onUpdate(file, rawSource, transformed);
-              debug2("html handle: %s", file);
+              debug3("html handle: %s", file);
               return {
                 result: transformed
               };
@@ -979,30 +1080,53 @@ function createGenerateBundleHook(context) {
       if (type === "css" && originalSource.type === "asset") {
         metrics.css.total++;
         const rawSource = originalEntrySource;
+        const cssRuntimeAffectingSignature = snapshot.runtimeAffectingSignatureByFile.get(file) ?? rawSource;
+        const shareCssResult = canShareCssTransformResult(rawSource);
+        const cssSharedCacheKey = shareCssResult ? `${runtimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}:${getCssHandlerOptions(file).isMainChunk ? "1" : "0"}:${cssRuntimeAffectingSignature}` : void 0;
         tasks.push(
           processCachedTask({
             cache,
             cacheKey: file,
-            rawSource,
             hashKey: `${file}:css:${runtimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}`,
+            rawSource: cssRuntimeAffectingSignature,
             applyResult(source) {
               originalSource.source = source;
             },
             onCacheHit() {
               metrics.css.cacheHits++;
-              debug2("css cache hit: %s", file);
+              debug3("css cache hit: %s", file);
             },
             async transform() {
-              const start = performance.now();
-              await runtimeState.patchPromise;
-              const { css } = await styleHandler(rawSource, getCssHandlerOptions(file));
-              if (debugCssDiff) {
-                debug2("css diff %s: %s", file, summarizeStringDiff(rawSource, css));
+              if (cssSharedCacheKey) {
+                const sharedCssTask = sharedCssResultCache.get(cssSharedCacheKey);
+                if (sharedCssTask != null) {
+                  metrics.css.cacheHits++;
+                  debug3("css shared hit: %s", file);
+                  const sharedCss = await sharedCssTask;
+                  onUpdate(file, rawSource, sharedCss);
+                  return {
+                    result: sharedCss
+                  };
+                }
               }
-              metrics.css.elapsed += measureElapsed(start);
-              metrics.css.transformed++;
+              const runTransform = async () => {
+                const start = performance.now();
+                await runtimeState.patchPromise;
+                const { css: css2 } = await styleHandler(rawSource, getCssHandlerOptions(file));
+                if (debugCssDiff) {
+                  debug3("css diff %s: %s", file, summarizeStringDiff(rawSource, css2));
+                }
+                metrics.css.elapsed += measureElapsed(start);
+                metrics.css.transformed++;
+                return css2;
+              };
+              const cssTask = cssSharedCacheKey ? sharedCssResultCache.get(cssSharedCacheKey) ?? runTransform() : runTransform();
+              if (cssSharedCacheKey && !sharedCssResultCache.has(cssSharedCacheKey)) {
+                sharedCssResultCache.set(cssSharedCacheKey, cssTask);
+              }
+              const css = await cssTask;
               onUpdate(file, rawSource, css);
-              debug2("css handle: %s", file);
+              debug3("css handle: %s", file);
               return {
                 result: css
               };
@@ -1015,21 +1139,23 @@ function createGenerateBundleHook(context) {
         continue;
       }
       metrics.js.total++;
-      const shouldTransformJs = processFiles.js.has(file);
+      const shouldTransformJs = !useIncrementalMode || processFiles.js.has(file);
       if (!shouldTransformJs) {
-        debug2("js skip transform (clean), replay cache: %s", file);
+        debug3("js skip transform (clean), replay cache: %s", file);
       }
       if (originalSource.type === "chunk") {
         const absoluteFile = path2.resolve(outDir, file);
         const initialRawSource = originalEntrySource;
-        const linkedSet = /* @__PURE__ */ new Set();
-        linkedByEntry.set(file, linkedSet);
+        const linkedSet = useIncrementalMode ? /* @__PURE__ */ new Set() : void 0;
+        if (linkedByEntry && linkedSet) {
+          linkedByEntry.set(file, linkedSet);
+        }
         jsTaskFactories.push(async () => {
-          const linkedImpactSignature = createLinkedImpactSignature(
+          const linkedImpactSignature = useIncrementalMode ? createLinkedImpactSignature(
             file,
             snapshot.linkedImpactsByEntry,
             snapshot.sourceHashByFile
-          );
+          ) : void 0;
           const hashSalt = createJsHashSalt(runtimeSignature, linkedImpactSignature);
           await processCachedTask({
             cache,
@@ -1042,13 +1168,13 @@ function createGenerateBundleHook(context) {
             },
             onCacheHit() {
               metrics.js.cacheHits++;
-              debug2("js cache hit: %s", file);
+              debug3("js cache hit: %s", file);
             },
             async transform() {
               const start = performance.now();
               const rawSource = originalSource.code;
               if (!shouldTransformJs) {
-                debug2("js cache replay miss, fallback transform: %s", file);
+                debug3("js cache replay miss, fallback transform: %s", file);
               }
               const handlerOptions = createHandlerOptions(absoluteFile);
               if (!disableJsPrecheck && shouldSkipViteJsTransform(rawSource, handlerOptions)) {
@@ -1062,11 +1188,11 @@ function createGenerateBundleHook(context) {
               metrics.js.elapsed += measureElapsed(start);
               metrics.js.transformed++;
               onUpdate(file, rawSource, code);
-              debug2("js handle: %s", file);
+              debug3("js handle: %s", file);
               if (linked) {
                 for (const id of Object.keys(linked)) {
                   const linkedEntry = jsEntries.get(id);
-                  if (linkedEntry) {
+                  if (linkedEntry && linkedSet) {
                     linkedSet.add(linkedEntry.fileName);
                   }
                 }
@@ -1079,14 +1205,16 @@ function createGenerateBundleHook(context) {
           });
         });
       } else if (uniAppX && originalSource.type === "asset") {
-        const linkedSet = /* @__PURE__ */ new Set();
-        linkedByEntry.set(file, linkedSet);
+        const linkedSet = useIncrementalMode ? /* @__PURE__ */ new Set() : void 0;
+        if (linkedByEntry && linkedSet) {
+          linkedByEntry.set(file, linkedSet);
+        }
         const baseApplyLinkedUpdates = applyLinkedUpdates;
         const wrappedApplyLinkedUpdates = (linked) => {
           if (linked) {
             for (const id of Object.keys(linked)) {
               const linkedEntry = jsEntries.get(id);
-              if (linkedEntry) {
+              if (linkedEntry && linkedSet) {
                 linkedSet.add(linkedEntry.fileName);
               }
             }
@@ -1102,14 +1230,14 @@ function createGenerateBundleHook(context) {
             hashKey: `${file}:js`,
             hashSalt: createJsHashSalt(
               runtimeSignature,
-              createLinkedImpactSignature(
+              useIncrementalMode ? createLinkedImpactSignature(
                 file,
                 snapshot.linkedImpactsByEntry,
                 snapshot.sourceHashByFile
-              )
+              ) : void 0
             ),
             createHandlerOptions,
-            debug: debug2,
+            debug: debug3,
             jsHandler,
             onUpdate,
             runtimeSet: runtime,
@@ -1120,7 +1248,7 @@ function createGenerateBundleHook(context) {
         jsTaskFactories.push(async () => {
           const start = performance.now();
           if (!shouldTransformJs) {
-            debug2("js skip transform (clean, uni-app-x), replay cache: %s", file);
+            debug3("js skip transform (clean, uni-app-x), replay cache: %s", file);
             await factory();
             metrics.js.elapsed += measureElapsed(start);
             metrics.js.transformed++;
@@ -1151,10 +1279,15 @@ function createGenerateBundleHook(context) {
     for (const apply of pendingLinkedUpdates) {
       apply();
     }
-    updateBundleBuildState(state, snapshot, linkedByEntry);
-    debug2(
+    updateBundleBuildState(
+      state,
+      snapshot,
+      useIncrementalMode ? linkedByEntry ?? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map(),
+      { incremental: useIncrementalMode }
+    );
+    debug3(
       "metrics iteration=%d runtime=%sms html(total=%d transform=%d hit=%d rate=%s elapsed=%sms) js(total=%d transform=%d hit=%d rate=%s elapsed=%sms) css(total=%d transform=%d hit=%d rate=%s elapsed=%sms)",
-      state.iteration,
+      useIncrementalMode ? state.iteration : 0,
       formatMs(metrics.runtimeSet),
       metrics.html.total,
       metrics.html.transformed,
@@ -1173,7 +1306,363 @@ function createGenerateBundleHook(context) {
       formatMs(metrics.css.elapsed)
     );
     onEnd();
-    debug2("end");
+    debug3("end");
+  };
+}
+
+// src/bundlers/vite/incremental-runtime-class-set.ts
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { createRequire } from "module";
+import path3 from "path";
+import process3 from "process";
+import { extractRawCandidatesWithPositions, extractValidCandidates } from "tailwindcss-patch";
+var debug = createDebug("[vite:runtime-set] ");
+var require2 = createRequire(import.meta.url);
+var EXTENSION_DOT_PREFIX_RE = /^\./;
+var VALIDATION_FILE_NAME = "runtime-candidates.html";
+var tailwindNodeModulePromise;
+function toPosixPath(value) {
+  return value.replaceAll("\\", "/");
+}
+function createCssImportSource(imports) {
+  return imports.map((value) => `@import "${toPosixPath(value)}";`).join("\n");
+}
+function isPostcssPluginImportTarget(value) {
+  if (!value) {
+    return false;
+  }
+  return value === "@tailwindcss/postcss" || value === "@tailwindcss/postcss7-compat" || value.includes("/postcss");
+}
+function resolveTailwindCssImportTarget(patcher) {
+  const tailwindOptions = resolveTailwindcssOptions(patcher.options);
+  const cssEntries = tailwindOptions?.v4?.cssEntries?.filter((item) => typeof item === "string" && item.length > 0);
+  if (cssEntries && cssEntries.length > 0) {
+    return createCssImportSource(cssEntries);
+  }
+  const configuredPackageName = tailwindOptions?.packageName;
+  if (typeof configuredPackageName === "string" && configuredPackageName.length > 0 && !isPostcssPluginImportTarget(configuredPackageName)) {
+    return createCssImportSource([configuredPackageName]);
+  }
+  const packageName = patcher.packageInfo?.name;
+  if (typeof packageName === "string" && packageName.length > 0 && !isPostcssPluginImportTarget(packageName)) {
+    return createCssImportSource([packageName]);
+  }
+  return createCssImportSource(["tailwindcss"]);
+}
+function getProjectRoot(patcher) {
+  return patcher.options?.projectRoot ?? process3.cwd();
+}
+async function importTailwindNodeModule() {
+  if (!tailwindNodeModulePromise) {
+    tailwindNodeModulePromise = (async () => {
+      try {
+        const resolved = require2.resolve("@tailwindcss/node");
+        return await import(resolved);
+      } catch {
+        const tailwindcssPatchEntry = require2.resolve("tailwindcss-patch");
+        const resolved = require2.resolve("@tailwindcss/node", {
+          paths: [path3.dirname(tailwindcssPatchEntry)]
+        });
+        return await import(resolved);
+      }
+    })();
+  }
+  return tailwindNodeModulePromise;
+}
+function resolveMaybeAbsolute(base, value) {
+  if (!value) {
+    return void 0;
+  }
+  return path3.isAbsolute(value) ? value : path3.resolve(base, value);
+}
+async function resolveTailwindCssSource(patcher) {
+  const projectRoot = getProjectRoot(patcher);
+  const tailwindOptions = resolveTailwindcssOptions(patcher.options);
+  const configuredBase = resolveMaybeAbsolute(projectRoot, tailwindOptions?.v4?.base);
+  const configDir = tailwindOptions?.config ? path3.dirname(tailwindOptions.config) : void 0;
+  const sharedFallbacks = [
+    configuredBase,
+    projectRoot,
+    tailwindOptions?.cwd,
+    configDir
+  ].filter((item) => typeof item === "string" && item.length > 0);
+  if (tailwindOptions?.v4?.css) {
+    return {
+      projectRoot,
+      base: configuredBase ?? projectRoot,
+      baseFallbacks: [...new Set(sharedFallbacks)],
+      css: tailwindOptions.v4.css
+    };
+  }
+  const cssEntries = tailwindOptions?.v4?.cssEntries?.filter((item) => typeof item === "string" && item.length > 0) ?? [];
+  if (cssEntries.length > 0) {
+    const resolvedEntries = cssEntries.map((entry) => resolveMaybeAbsolute(projectRoot, entry) ?? entry);
+    const cssChunks = [];
+    const entryDirs = [];
+    for (const entry of resolvedEntries) {
+      try {
+        cssChunks.push(await readFile(entry, "utf8"));
+        entryDirs.push(path3.dirname(entry));
+      } catch {
+      }
+    }
+    if (cssChunks.length > 0) {
+      const base = entryDirs[0] ?? configuredBase ?? projectRoot;
+      const baseFallbacks = [...new Set([
+        ...entryDirs.slice(1),
+        ...sharedFallbacks
+      ].filter((item) => typeof item === "string" && item.length > 0 && item !== base))];
+      return {
+        projectRoot,
+        base,
+        baseFallbacks,
+        css: cssChunks.join("\n")
+      };
+    }
+  }
+  return {
+    projectRoot,
+    base: configuredBase ?? projectRoot,
+    baseFallbacks: [...new Set(sharedFallbacks)],
+    css: resolveTailwindCssImportTarget(patcher)
+  };
+}
+function createExtractOptions(context, tempRoot, pattern) {
+  return {
+    cwd: context.projectRoot,
+    base: context.base,
+    baseFallbacks: context.baseFallbacks,
+    css: context.css,
+    sources: [{
+      base: tempRoot,
+      pattern,
+      negated: false
+    }]
+  };
+}
+function createRuntimeEntries(snapshot) {
+  return snapshot.entries.filter((entry) => entry.type === "html" || entry.type === "js");
+}
+function collectChangedRuntimeFiles(snapshot) {
+  return /* @__PURE__ */ new Set([
+    ...snapshot.runtimeAffectingChangedByType.html,
+    ...snapshot.runtimeAffectingChangedByType.js
+  ]);
+}
+async function writeTempEntryFile(tempRoot, file, source) {
+  const absoluteFile = path3.join(tempRoot, file);
+  await mkdir(path3.dirname(absoluteFile), { recursive: true });
+  await writeFile(absoluteFile, source, "utf8");
+  return file;
+}
+function resolveEntryExtension(entry) {
+  const ext = path3.extname(entry.file).replace(EXTENSION_DOT_PREFIX_RE, "");
+  if (ext.length > 0) {
+    return ext;
+  }
+  return entry.type === "html" ? "html" : "js";
+}
+function createCandidateValidationSource(candidates) {
+  return [...new Set(candidates)].sort().join("\n");
+}
+function removeCandidateSet(candidateCountByClass, runtimeSet, candidates) {
+  for (const className of candidates) {
+    const count = candidateCountByClass.get(className);
+    if (count == null) {
+      continue;
+    }
+    if (count <= 1) {
+      candidateCountByClass.delete(className);
+      runtimeSet.delete(className);
+      continue;
+    }
+    candidateCountByClass.set(className, count - 1);
+  }
+}
+function addCandidateSet(candidateCountByClass, runtimeSet, candidates) {
+  for (const className of candidates) {
+    const nextCount = (candidateCountByClass.get(className) ?? 0) + 1;
+    candidateCountByClass.set(className, nextCount);
+    runtimeSet.add(className);
+  }
+}
+function createBundleRuntimeClassSetManager(options = {}) {
+  const customExtractCandidates = options.extractCandidates;
+  const extractCandidates = customExtractCandidates ?? extractValidCandidates;
+  const extractRawCandidates = options.extractRawCandidates ?? extractRawCandidatesWithPositions;
+  const runtimeSet = /* @__PURE__ */ new Set();
+  const candidateCountByClass = /* @__PURE__ */ new Map();
+  const candidatesByFile = /* @__PURE__ */ new Map();
+  const candidateValidityCache = /* @__PURE__ */ new Map();
+  let runtimeSignature;
+  let resolvedTempRoot;
+  let validationContext;
+  let designSystemPromise;
+  async function reset() {
+    runtimeSet.clear();
+    candidateCountByClass.clear();
+    candidatesByFile.clear();
+    candidateValidityCache.clear();
+    runtimeSignature = void 0;
+    validationContext = void 0;
+    designSystemPromise = void 0;
+    if (resolvedTempRoot) {
+      await rm(resolvedTempRoot, { recursive: true, force: true });
+      resolvedTempRoot = void 0;
+    }
+  }
+  async function resolveValidationContextCached(patcher) {
+    if (!validationContext) {
+      validationContext = await resolveTailwindCssSource(patcher);
+    }
+    return validationContext;
+  }
+  async function loadDesignSystem(context) {
+    if (!designSystemPromise) {
+      designSystemPromise = (async () => {
+        const { __unstable__loadDesignSystem } = await importTailwindNodeModule();
+        let lastError;
+        for (const base of [context.base, ...context.baseFallbacks]) {
+          try {
+            return await __unstable__loadDesignSystem(context.css, { base });
+          } catch (error) {
+            lastError = error;
+          }
+        }
+        throw lastError instanceof Error ? lastError : new Error("Failed to load Tailwind CSS design system for incremental runtime validation.");
+      })();
+    }
+    return designSystemPromise;
+  }
+  function populateCandidateValidityCacheFromDesignSystem(designSystem, unknownCandidates) {
+    const parsedCandidates = [...unknownCandidates].filter((candidate) => designSystem.parseCandidate(candidate).length > 0);
+    const cssByCandidate = parsedCandidates.length > 0 ? designSystem.candidatesToCss(parsedCandidates) : [];
+    const validCandidates = /* @__PURE__ */ new Set();
+    for (let index = 0; index < parsedCandidates.length; index += 1) {
+      const candidate = parsedCandidates[index];
+      const css = cssByCandidate[index];
+      if (candidate && typeof css === "string" && css.trim().length > 0) {
+        validCandidates.add(candidate);
+      }
+    }
+    for (const candidate of unknownCandidates) {
+      candidateValidityCache.set(candidate, validCandidates.has(candidate));
+    }
+  }
+  async function validateUnknownCandidates(patcher, tempRoot, unknownCandidates) {
+    if (unknownCandidates.size === 0) {
+      return;
+    }
+    const context = await resolveValidationContextCached(patcher);
+    if (!customExtractCandidates) {
+      try {
+        const designSystem = await loadDesignSystem(context);
+        populateCandidateValidityCacheFromDesignSystem(designSystem, unknownCandidates);
+        return;
+      } catch (error) {
+        debug("incremental design-system validation failed, fallback to extractValidCandidates: %O", error);
+        designSystemPromise = void 0;
+      }
+    }
+    const source = createCandidateValidationSource(unknownCandidates);
+    const pattern = await writeTempEntryFile(tempRoot, VALIDATION_FILE_NAME, source);
+    const validCandidates = new Set(await extractCandidates(createExtractOptions(context, tempRoot, pattern)));
+    for (const candidate of unknownCandidates) {
+      candidateValidityCache.set(candidate, validCandidates.has(candidate));
+    }
+  }
+  async function extractEntryRawCandidates(entry) {
+    const matches = await extractRawCandidates(entry.source, resolveEntryExtension(entry));
+    const candidates = /* @__PURE__ */ new Set();
+    for (const match of matches) {
+      const candidate = match?.rawCandidate;
+      if (typeof candidate === "string" && candidate.length > 0) {
+        candidates.add(candidate);
+      }
+    }
+    return candidates;
+  }
+  async function sync(patcher, snapshot) {
+    const nextSignature = getRuntimeClassSetSignature(patcher) ?? "runtime:missing";
+    const runtimeEntries = createRuntimeEntries(snapshot);
+    const runtimeEntriesByFile = new Map(runtimeEntries.map((entry) => [entry.file, entry]));
+    const currentRuntimeFiles = new Set(runtimeEntriesByFile.keys());
+    const fullRebuild = runtimeSignature !== nextSignature || candidatesByFile.size === 0;
+    if (runtimeSignature !== nextSignature) {
+      debug("runtime signature changed, reset incremental runtime set: %s", nextSignature);
+      await reset();
+    }
+    runtimeSignature = nextSignature;
+    const projectRoot = getProjectRoot(patcher);
+    resolvedTempRoot = options.tempRoot ?? path3.join(
+      projectRoot,
+      "node_modules",
+      ".cache",
+      "weapp-tailwindcss",
+      "vite-runtime-set"
+    );
+    for (const [file, previousCandidates] of candidatesByFile) {
+      if (currentRuntimeFiles.has(file)) {
+        continue;
+      }
+      removeCandidateSet(candidateCountByClass, runtimeSet, previousCandidates);
+      candidatesByFile.delete(file);
+    }
+    const changedRuntimeFiles = fullRebuild ? [...runtimeEntriesByFile.keys()] : [...collectChangedRuntimeFiles(snapshot)];
+    if (changedRuntimeFiles.length === 0) {
+      return new Set(runtimeSet);
+    }
+    const rawCandidatesByFile = /* @__PURE__ */ new Map();
+    const unknownCandidates = /* @__PURE__ */ new Set();
+    await Promise.all(changedRuntimeFiles.map(async (file) => {
+      const entry = runtimeEntriesByFile.get(file);
+      if (!entry) {
+        return;
+      }
+      const candidates = await extractEntryRawCandidates(entry);
+      rawCandidatesByFile.set(file, candidates);
+      for (const candidate of candidates) {
+        if (!candidateValidityCache.has(candidate)) {
+          unknownCandidates.add(candidate);
+        }
+      }
+    }));
+    await validateUnknownCandidates(patcher, resolvedTempRoot, unknownCandidates);
+    let rawCandidateCount = 0;
+    for (const file of changedRuntimeFiles) {
+      const nextRawCandidates = rawCandidatesByFile.get(file);
+      const previousCandidates = candidatesByFile.get(file);
+      if (previousCandidates) {
+        removeCandidateSet(candidateCountByClass, runtimeSet, previousCandidates);
+      }
+      if (!nextRawCandidates || nextRawCandidates.size === 0) {
+        candidatesByFile.delete(file);
+        continue;
+      }
+      rawCandidateCount += nextRawCandidates.size;
+      const nextCandidates = new Set(
+        [...nextRawCandidates].filter((candidate) => candidateValidityCache.get(candidate) === true)
+      );
+      if (nextCandidates.size === 0) {
+        candidatesByFile.delete(file);
+        continue;
+      }
+      addCandidateSet(candidateCountByClass, runtimeSet, nextCandidates);
+      candidatesByFile.set(file, nextCandidates);
+    }
+    debug(
+      "incremental runtime set synced, changedFiles=%d rawCandidates=%d validateMisses=%d runtimeSize=%d trackedFiles=%d",
+      changedRuntimeFiles.length,
+      rawCandidateCount,
+      unknownCandidates.size,
+      runtimeSet.size,
+      candidatesByFile.size
+    );
+    return new Set(runtimeSet);
+  }
+  return {
+    sync,
+    reset
   };
 }
 
@@ -1240,9 +1729,35 @@ function createRewriteCssImportsPlugins(options) {
 }
 
 // src/bundlers/vite/index.ts
-var debug = createDebug();
+var debug2 = createDebug();
 var weappTailwindcssPackageDir = resolvePackageDir("weapp-tailwindcss");
 var weappTailwindcssDirPosix = slash(weappTailwindcssPackageDir);
+var PACKAGE_JSON_FILE = "package.json";
+function resolveImplicitTailwindcssBasedirFromViteRoot(root) {
+  const resolvedRoot = path4.resolve(root);
+  if (!existsSync(resolvedRoot)) {
+    return resolvedRoot;
+  }
+  const searchRoots = [];
+  let current = resolvedRoot;
+  while (true) {
+    searchRoots.push(current);
+    const parent = path4.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  const tailwindConfigPath = findTailwindConfig(searchRoots);
+  if (tailwindConfigPath) {
+    return path4.dirname(tailwindConfigPath);
+  }
+  const packageRoot = findNearestPackageRoot(resolvedRoot);
+  if (packageRoot && existsSync(path4.join(packageRoot, PACKAGE_JSON_FILE))) {
+    return packageRoot;
+  }
+  return resolvedRoot;
+}
 function UnifiedViteWeappTailwindcssPlugin(options = {}) {
   const rewriteCssImportsSpecified = Object.hasOwn(options, "rewriteCssImports");
   const hasExplicitTailwindcssBasedir = typeof options.tailwindcssBasedir === "string" && options.tailwindcssBasedir.trim().length > 0;
@@ -1274,7 +1789,7 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
   const customAttributesEntities = toCustomAttributesEntities(customAttributes);
   const patchRecorderState = setupPatchRecorder(initialTwPatcher, opts.tailwindcssBasedir, {
     source: "runtime",
-    cwd: opts.tailwindcssBasedir ?? process3.cwd()
+    cwd: opts.tailwindcssBasedir ?? process4.cwd()
   });
   const runtimeState = {
     twPatcher: initialTwPatcher,
@@ -1287,8 +1802,9 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
   let resolvedConfig;
   let runtimeRefreshSignature;
   let runtimeRefreshOptionsKey;
+  const bundleRuntimeClassSetManager = createBundleRuntimeClassSetManager();
   function resolveRuntimeRefreshOptions() {
-    const configPath = runtimeState.twPatcher.options?.tailwind?.config;
+    const configPath = resolveTailwindcssOptions(runtimeState.twPatcher.options)?.config;
     const signature = getRuntimeClassSetSignature(runtimeState.twPatcher);
     const optionsKey = JSON.stringify({
       appType,
@@ -1315,7 +1831,7 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
       clearCache: force || invalidation.changed
     });
     if (invalidation.changed) {
-      debug("runtime signature changed, refresh triggered. signature: %s", invalidation.signature);
+      debug2("runtime signature changed, refresh triggered. signature: %s", invalidation.signature);
     }
     if (refreshed) {
       runtimeSet = void 0;
@@ -1323,7 +1839,7 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
     }
   }
   async function ensureRuntimeClassSet(force = false) {
-    const forceRuntimeRefresh = force || process3.env.WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH === "1";
+    const forceRuntimeRefresh = force || process4.env.WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH === "1";
     await refreshRuntimeState(force);
     await runtimeState.patchPromise;
     if (!forceRuntimeRefresh && runtimeSet) {
@@ -1348,6 +1864,46 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
       }
     }
   }
+  async function ensureBundleRuntimeClassSet(snapshot, forceRefresh = false) {
+    const forceRuntimeRefresh = forceRefresh || process4.env.WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH === "1";
+    const invalidation = resolveRuntimeRefreshOptions();
+    const shouldRefreshPatcher = forceRuntimeRefresh || invalidation.changed;
+    const forceCollectBySource = snapshot.runtimeAffectingChangedByType.html.size > 0 || snapshot.runtimeAffectingChangedByType.js.size > 0;
+    await refreshRuntimeState(shouldRefreshPatcher);
+    await runtimeState.patchPromise;
+    if (shouldRefreshPatcher) {
+      runtimeSet = void 0;
+      runtimeSetPromise = void 0;
+      await bundleRuntimeClassSetManager.reset();
+    }
+    if (runtimeState.twPatcher.majorVersion === 4 && !forceRuntimeRefresh) {
+      try {
+        const nextRuntimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.twPatcher, snapshot);
+        runtimeSet = nextRuntimeSet;
+        return nextRuntimeSet;
+      } catch (error) {
+        debug2("incremental runtime set sync failed, fallback to full collect: %O", error);
+        await bundleRuntimeClassSetManager.reset();
+      }
+    }
+    if (!forceRuntimeRefresh && !invalidation.changed && !forceCollectBySource && runtimeSet) {
+      return runtimeSet;
+    }
+    const task = collectRuntimeClassSet(runtimeState.twPatcher, {
+      force: forceRuntimeRefresh || invalidation.changed || forceCollectBySource,
+      skipRefresh: forceRuntimeRefresh,
+      clearCache: forceRuntimeRefresh || invalidation.changed
+    });
+    runtimeSetPromise = task;
+    try {
+      runtimeSet = await task;
+      return runtimeSet;
+    } finally {
+      if (runtimeSetPromise === task) {
+        runtimeSetPromise = void 0;
+      }
+    }
+  }
   onLoad();
   const getResolvedConfig = () => resolvedConfig;
   const utsPlatform = resolveUniUtsPlatform();
@@ -1371,12 +1927,19 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
       enforce: "post",
       async configResolved(config) {
         resolvedConfig = config;
-        const resolvedRoot = config.root ? path3.resolve(config.root) : void 0;
-        if (!hasExplicitTailwindcssBasedir && resolvedRoot && opts.tailwindcssBasedir !== resolvedRoot) {
-          const previousBasedir = opts.tailwindcssBasedir;
-          opts.tailwindcssBasedir = resolvedRoot;
-          debug("align tailwindcss basedir with vite root: %s -> %s", previousBasedir ?? "undefined", resolvedRoot);
-          await refreshRuntimeState(true);
+        const resolvedRoot = config.root ? path4.resolve(config.root) : void 0;
+        if (!hasExplicitTailwindcssBasedir && resolvedRoot) {
+          const nextTailwindcssBasedir = resolveImplicitTailwindcssBasedirFromViteRoot(resolvedRoot);
+          if (opts.tailwindcssBasedir !== nextTailwindcssBasedir) {
+            const previousBasedir = opts.tailwindcssBasedir;
+            opts.tailwindcssBasedir = nextTailwindcssBasedir;
+            debug2(
+              "align tailwindcss basedir with vite root: %s -> %s",
+              previousBasedir ?? "undefined",
+              nextTailwindcssBasedir
+            );
+            await refreshRuntimeState(true);
+          }
         }
         if (typeof config.css.postcss === "object" && Array.isArray(config.css.postcss.plugins)) {
           const postcssPlugins = config.css.postcss.plugins;
@@ -1386,7 +1949,7 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
           ));
           if (idx > -1) {
             postcssPlugins.splice(idx, 1, postcssHtmlTransform());
-            debug("remove postcss-html-transform plugin from vite config");
+            debug2("remove postcss-html-transform plugin from vite config");
           }
         }
       },
@@ -1394,7 +1957,8 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
         opts,
         runtimeState,
         ensureRuntimeClassSet,
-        debug,
+        ensureBundleRuntimeClassSet,
+        debug: debug2,
         getResolvedConfig
       })
     }