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

package/dist/{chunk-FKUPQQYX.js → chunk-K7CZXT46.js}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 
 
@@ -6,13 +6,12 @@
 
 
 
-var _chunkG3G437UEjs = require('./chunk-G3G437UE.js');
+var _chunk7LKMJZD2js = require('./chunk-7LKMJZD2.js');
 
 
-var _chunkLTJQUORKjs = require('./chunk-LTJQUORK.js');
+var _chunkOF6MFURRjs = require('./chunk-OF6MFURR.js');
 
 
-var _chunkPXZUQ7RRjs = require('./chunk-PXZUQ7RR.js');
 
 
 
@@ -24,14 +23,22 @@ var _chunkPXZUQ7RRjs = require('./chunk-PXZUQ7RR.js');
 
 
 
+var _chunkLYGLQCWIjs = require('./chunk-LYGLQCWI.js');
 
 
-var _chunkI4EOMKX2js = require('./chunk-I4EOMKX2.js');
+
+
+
+var _chunk5KSBT6GUjs = require('./chunk-5KSBT6GU.js');
 
 
 var _chunkDYLQ6UOIjs = require('./chunk-DYLQ6UOI.js');
 
+
+var _chunkCRDOWYG4js = require('./chunk-CRDOWYG4.js');
+
 // src/bundlers/vite/index.ts
+var _fs = require('fs');
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 var _process = require('process'); var _process2 = _interopRequireDefault(_process);
 var _htmltransform = require('@weapp-tailwindcss/postcss/html-transform'); var _htmltransform2 = _interopRequireDefault(_htmltransform);
@@ -57,7 +64,7 @@ function updateStaticAttribute(ms, prop) {
   const start = prop.value.loc.start.offset + 1;
   const end = prop.value.loc.end.offset - 1;
   if (start < end) {
-    ms.update(start, end, _chunkI4EOMKX2js.replaceWxml.call(void 0, prop.value.content));
+    ms.update(start, end, _chunkLYGLQCWIjs.replaceWxml.call(void 0, prop.value.content));
   }
 }
 function updateDirectiveExpression(ms, prop, jsHandler, runtimeSet) {
@@ -69,7 +76,7 @@ function updateDirectiveExpression(ms, prop, jsHandler, runtimeSet) {
   if (start >= end) {
     return;
   }
-  const generated = _chunkI4EOMKX2js.generateCode.call(void 0, prop.exp.content, {
+  const generated = _chunkLYGLQCWIjs.generateCode.call(void 0, prop.exp.content, {
     jsHandler,
     runtimeSet,
     wrapExpression: true
@@ -99,7 +106,7 @@ function transformUVue(code, id, jsHandler, runtimeSet, options = {}) {
     return;
   }
   const { customAttributesEntities, disabledDefaultTemplateHandler = false } = options;
-  const matchCustomAttribute = _chunkI4EOMKX2js.createAttributeMatcher.call(void 0, customAttributesEntities);
+  const matchCustomAttribute = _chunkLYGLQCWIjs.createAttributeMatcher.call(void 0, customAttributesEntities);
   const ms = new (0, _magicstring2.default)(code);
   const { descriptor, errors } = _compilersfc.parse.call(void 0, code);
   if (errors.length === 0) {
@@ -369,17 +376,17 @@ function createUniAppXAssetTask(file, originalSource, outDir, options) {
       cache,
       hashKey,
       createHandlerOptions,
-      debug: debug2,
+      debug: debug3,
       jsHandler,
       onUpdate,
       runtimeSet,
       applyLinkedResults: applyLinkedResults2
     } = options;
-    const absoluteFile = _chunkG3G437UEjs.toAbsoluteOutputPath.call(void 0, file, outDir);
+    const absoluteFile = _chunk7LKMJZD2js.toAbsoluteOutputPath.call(void 0, file, outDir);
     const rawSource = originalSource.source.toString();
     const rawHashSource = options.hashSalt ? `${rawSource}
 /*${options.hashSalt}*/` : rawSource;
-    await _chunkLTJQUORKjs.processCachedTask.call(void 0, {
+    await _chunkOF6MFURRjs.processCachedTask.call(void 0, {
       cache,
       cacheKey: file,
       hashKey,
@@ -388,7 +395,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 +409,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 +422,8 @@ function createUniAppXAssetTask(file, originalSource, outDir, options) {
 // src/bundlers/vite/generate-bundle.ts
 
 
+var _logger = require('@weapp-tailwindcss/logger');
+var _extractors = require('@weapp-tailwindcss/shared/extractors');
 
 // src/bundlers/vite/bundle-entries.ts
 var _buffer = require('buffer');
@@ -447,7 +456,7 @@ function isJavaScriptEntry(entry) {
 function createBundleModuleGraphOptions(outputDir, entries) {
   return {
     resolve(specifier, importer) {
-      return _chunkG3G437UEjs.resolveOutputSpecifier.call(void 0, specifier, importer, outputDir, (candidate) => entries.has(candidate));
+      return _chunk7LKMJZD2js.resolveOutputSpecifier.call(void 0, specifier, importer, outputDir, (candidate) => entries.has(candidate));
     },
     load(id) {
       const entry = entries.get(id);
@@ -486,6 +495,10 @@ function applyLinkedResults(linked, entries, onLinkedUpdate, onApplied) {
 
 // src/bundlers/vite/runtime-affecting-signature.ts
 var _htmlparser2 = require('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 = [];
@@ -517,23 +530,23 @@ function createHtmlRuntimeAffectingSignature(source) {
 }
 function createJsRuntimeAffectingSignature(source) {
   try {
-    const ast = _chunkI4EOMKX2js.babelParse.call(void 0, source, {
+    const ast = _chunkLYGLQCWIjs.babelParse.call(void 0, source, {
       cache: true,
       cacheKey: "vite-runtime-affecting:unambiguous",
       plugins: ["jsx", "typescript"],
       sourceType: "unambiguous"
     });
     const parts = [];
-    _chunkI4EOMKX2js.traverse.call(void 0, ast, {
+    _chunkLYGLQCWIjs.traverse.call(void 0, 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 +565,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 +575,9 @@ function createRuntimeAffectingSourceSignature(source, type) {
   if (type === "js") {
     return createJsRuntimeAffectingSignature(source);
   }
+  if (type === "css") {
+    return createCssRuntimeAffectingSignature(source);
+  }
   return source;
 }
 
@@ -610,7 +629,7 @@ function collectJsEntries(fileName, output, outDir, store) {
   if (!isJavaScriptEntry(entry)) {
     return;
   }
-  const absolute = _chunkG3G437UEjs.toAbsoluteOutputPath.call(void 0, fileName, outDir);
+  const absolute = _chunk7LKMJZD2js.toAbsoluteOutputPath.call(void 0, fileName, outDir);
   store.set(absolute, entry);
 }
 function markProcessFile(type, file, processFiles) {
@@ -620,6 +639,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 +654,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 +703,7 @@ function buildBundleSnapshot(bundle, opts, outDir, state, forceAll = false) {
     entries,
     jsEntries,
     sourceHashByFile,
+    runtimeAffectingSignatureByFile,
     runtimeAffectingHashByFile,
     changedByType,
     runtimeAffectingChangedByType,
@@ -703,12 +725,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 +845,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 _nullishCoalesce(source.match(MUSTACHE_EXPRESSION_RE), () => ( []))) {
+    QUOTED_LITERAL_RE.lastIndex = 0;
+    let quoted = QUOTED_LITERAL_RE.exec(expression);
+    while (quoted !== null) {
+      const literal = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(quoted[1], () => ( quoted[2])), () => ( quoted[3])), () => ( ""));
+      for (const candidate of _extractors.splitCode.call(void 0, 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 +888,8 @@ function createGenerateBundleHook(context) {
     const {
       opts,
       runtimeState,
-      ensureRuntimeClassSet,
-      debug: debug2,
+      ensureBundleRuntimeClassSet,
+      debug: debug3,
       getResolvedConfig
     } = context;
     const {
@@ -857,7 +925,7 @@ function createGenerateBundleHook(context) {
       return created;
     };
     await runtimeState.patchPromise;
-    debug2("start");
+    debug3("start");
     onStart();
     const metrics = createEmptyMetrics();
     const forceRuntimeRefreshByEnv = _process2.default.env.WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH === "1";
@@ -865,54 +933,69 @@ function createGenerateBundleHook(context) {
     const disableJsPrecheck = _process2.default.env.WEAPP_TW_VITE_DISABLE_JS_PRECHECK === "1";
     const debugCssDiff = _process2.default.env.WEAPP_TW_VITE_DEBUG_CSS_DIFF === "1";
     const resolvedConfig = getResolvedConfig();
-    const rootDir = _optionalChain([resolvedConfig, 'optionalAccess', _26 => _26.root]) ? _path2.default.resolve(resolvedConfig.root) : _process2.default.cwd();
-    const outDir = _optionalChain([resolvedConfig, 'optionalAccess', _27 => _27.build, 'optionalAccess', _28 => _28.outDir]) ? _path2.default.resolve(rootDir, resolvedConfig.build.outDir) : rootDir;
-    const snapshot = buildBundleSnapshot(bundle, opts, outDir, state, disableDirtyOptimization);
-    const forceRuntimeRefreshBySource = hasRuntimeAffectingSourceChanges(snapshot.runtimeAffectingChangedByType);
-    const forceRuntimeRefresh = forceRuntimeRefreshByEnv || forceRuntimeRefreshBySource;
+    const bundleFiles = Object.keys(bundle);
+    const buildCommand = _optionalChain([resolvedConfig, 'optionalAccess', _26 => _26.command]) === "build";
+    const useIncrementalMode = !buildCommand || hasOmittedKnownBundleFiles(bundleFiles, state.sourceHashByFile.keys());
+    const rootDir = _optionalChain([resolvedConfig, 'optionalAccess', _27 => _27.root]) ? _path2.default.resolve(resolvedConfig.root) : _process2.default.cwd();
+    const outDir = _optionalChain([resolvedConfig, 'optionalAccess', _28 => _28.build, 'optionalAccess', _29 => _29.outDir]) ? _path2.default.resolve(rootDir, resolvedConfig.build.outDir) : rootDir;
+    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);
-    const runtimeSignature = _nullishCoalesce(_chunkI4EOMKX2js.getRuntimeClassSetSignature.call(void 0, runtimeState.twPatcher), () => ( "runtime:missing"));
+    debug3("get runtimeSet, class count: %d", runtime.size);
+    const runtimeSignature = _nullishCoalesce(_chunk5KSBT6GUjs.getRuntimeClassSetSignature.call(void 0, 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) => {
@@ -933,11 +1016,12 @@ function createGenerateBundleHook(context) {
       tailwindcssMajorVersion: runtimeState.twPatcher.majorVersion,
       moduleGraph: moduleGraphOptions,
       babelParserOptions: {
-        ..._nullishCoalesce(_optionalChain([extra, 'optionalAccess', _29 => _29.babelParserOptions]), () => ( {})),
+        ..._nullishCoalesce(_optionalChain([extra, 'optionalAccess', _30 => _30.babelParserOptions]), () => ( {})),
         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) {
@@ -949,7 +1033,7 @@ function createGenerateBundleHook(context) {
         }
         const rawSource = originalEntrySource;
         tasks.push(
-          _chunkLTJQUORKjs.processCachedTask.call(void 0, {
+          _chunkOF6MFURRjs.processCachedTask.call(void 0, {
             cache,
             cacheKey: file,
             rawSource,
@@ -959,15 +1043,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.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.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 +1083,53 @@ function createGenerateBundleHook(context) {
       if (type === "css" && originalSource.type === "asset") {
         metrics.css.total++;
         const rawSource = originalEntrySource;
+        const cssRuntimeAffectingSignature = _nullishCoalesce(snapshot.runtimeAffectingSignatureByFile.get(file), () => ( rawSource));
+        const shareCssResult = canShareCssTransformResult(rawSource);
+        const cssSharedCacheKey = shareCssResult ? `${runtimeSignature}:${_nullishCoalesce(runtimeState.twPatcher.majorVersion, () => ( "unknown"))}:${getCssHandlerOptions(file).isMainChunk ? "1" : "0"}:${cssRuntimeAffectingSignature}` : void 0;
         tasks.push(
-          _chunkLTJQUORKjs.processCachedTask.call(void 0, {
+          _chunkOF6MFURRjs.processCachedTask.call(void 0, {
             cache,
             cacheKey: file,
-            rawSource,
             hashKey: `${file}:css:${runtimeSignature}:${_nullishCoalesce(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 ? _nullishCoalesce(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,23 +1142,25 @@ 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.default.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 _chunkLTJQUORKjs.processCachedTask.call(void 0, {
+          await _chunkOF6MFURRjs.processCachedTask.call(void 0, {
             cache,
             cacheKey: file,
             hashKey: `${file}:js`,
@@ -1042,13 +1171,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 +1191,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 +1208,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 +1233,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 +1251,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++;
@@ -1146,15 +1277,20 @@ function createGenerateBundleHook(context) {
         });
       }
     }
-    _chunkG3G437UEjs.pushConcurrentTaskFactories.call(void 0, tasks, jsTaskFactories);
+    _chunk7LKMJZD2js.pushConcurrentTaskFactories.call(void 0, tasks, jsTaskFactories);
     await Promise.all(tasks);
     for (const apply of pendingLinkedUpdates) {
       apply();
     }
-    updateBundleBuildState(state, snapshot, linkedByEntry);
-    debug2(
+    updateBundleBuildState(
+      state,
+      snapshot,
+      useIncrementalMode ? _nullishCoalesce(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 +1309,363 @@ function createGenerateBundleHook(context) {
       formatMs(metrics.css.elapsed)
     );
     onEnd();
-    debug2("end");
+    debug3("end");
+  };
+}
+
+// src/bundlers/vite/incremental-runtime-class-set.ts
+var _promises = require('fs/promises');
+var _module = require('module');
+
+
+var _tailwindcsspatch = require('tailwindcss-patch');
+var debug = _chunkLYGLQCWIjs.createDebug.call(void 0, "[vite:runtime-set] ");
+var require2 = _module.createRequire.call(void 0, _chunkCRDOWYG4js.importMetaUrl);
+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 = _chunk5KSBT6GUjs.resolveTailwindcssOptions.call(void 0, patcher.options);
+  const cssEntries = _optionalChain([tailwindOptions, 'optionalAccess', _31 => _31.v4, 'optionalAccess', _32 => _32.cssEntries, 'optionalAccess', _33 => _33.filter, 'call', _34 => _34((item) => typeof item === "string" && item.length > 0)]);
+  if (cssEntries && cssEntries.length > 0) {
+    return createCssImportSource(cssEntries);
+  }
+  const configuredPackageName = _optionalChain([tailwindOptions, 'optionalAccess', _35 => _35.packageName]);
+  if (typeof configuredPackageName === "string" && configuredPackageName.length > 0 && !isPostcssPluginImportTarget(configuredPackageName)) {
+    return createCssImportSource([configuredPackageName]);
+  }
+  const packageName = _optionalChain([patcher, 'access', _36 => _36.packageInfo, 'optionalAccess', _37 => _37.name]);
+  if (typeof packageName === "string" && packageName.length > 0 && !isPostcssPluginImportTarget(packageName)) {
+    return createCssImportSource([packageName]);
+  }
+  return createCssImportSource(["tailwindcss"]);
+}
+function getProjectRoot(patcher) {
+  return _nullishCoalesce(_optionalChain([patcher, 'access', _38 => _38.options, 'optionalAccess', _39 => _39.projectRoot]), () => ( _process2.default.cwd()));
+}
+async function importTailwindNodeModule() {
+  if (!tailwindNodeModulePromise) {
+    tailwindNodeModulePromise = (async () => {
+      try {
+        const resolved = require2.resolve("@tailwindcss/node");
+        return await Promise.resolve().then(() => _interopRequireWildcard(require(resolved)));
+      } catch (e3) {
+        const tailwindcssPatchEntry = require2.resolve("tailwindcss-patch");
+        const resolved = require2.resolve("@tailwindcss/node", {
+          paths: [_path2.default.dirname(tailwindcssPatchEntry)]
+        });
+        return await Promise.resolve().then(() => _interopRequireWildcard(require(resolved)));
+      }
+    })();
+  }
+  return tailwindNodeModulePromise;
+}
+function resolveMaybeAbsolute(base, value) {
+  if (!value) {
+    return void 0;
+  }
+  return _path2.default.isAbsolute(value) ? value : _path2.default.resolve(base, value);
+}
+async function resolveTailwindCssSource(patcher) {
+  const projectRoot = getProjectRoot(patcher);
+  const tailwindOptions = _chunk5KSBT6GUjs.resolveTailwindcssOptions.call(void 0, patcher.options);
+  const configuredBase = resolveMaybeAbsolute(projectRoot, _optionalChain([tailwindOptions, 'optionalAccess', _40 => _40.v4, 'optionalAccess', _41 => _41.base]));
+  const configDir = _optionalChain([tailwindOptions, 'optionalAccess', _42 => _42.config]) ? _path2.default.dirname(tailwindOptions.config) : void 0;
+  const sharedFallbacks = [
+    configuredBase,
+    projectRoot,
+    _optionalChain([tailwindOptions, 'optionalAccess', _43 => _43.cwd]),
+    configDir
+  ].filter((item) => typeof item === "string" && item.length > 0);
+  if (_optionalChain([tailwindOptions, 'optionalAccess', _44 => _44.v4, 'optionalAccess', _45 => _45.css])) {
+    return {
+      projectRoot,
+      base: _nullishCoalesce(configuredBase, () => ( projectRoot)),
+      baseFallbacks: [...new Set(sharedFallbacks)],
+      css: tailwindOptions.v4.css
+    };
+  }
+  const cssEntries = _nullishCoalesce(_optionalChain([tailwindOptions, 'optionalAccess', _46 => _46.v4, 'optionalAccess', _47 => _47.cssEntries, 'optionalAccess', _48 => _48.filter, 'call', _49 => _49((item) => typeof item === "string" && item.length > 0)]), () => ( []));
+  if (cssEntries.length > 0) {
+    const resolvedEntries = cssEntries.map((entry) => _nullishCoalesce(resolveMaybeAbsolute(projectRoot, entry), () => ( entry)));
+    const cssChunks = [];
+    const entryDirs = [];
+    for (const entry of resolvedEntries) {
+      try {
+        cssChunks.push(await _promises.readFile.call(void 0, entry, "utf8"));
+        entryDirs.push(_path2.default.dirname(entry));
+      } catch (e4) {
+      }
+    }
+    if (cssChunks.length > 0) {
+      const base = _nullishCoalesce(_nullishCoalesce(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: _nullishCoalesce(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 = _path2.default.join(tempRoot, file);
+  await _promises.mkdir.call(void 0, _path2.default.dirname(absoluteFile), { recursive: true });
+  await _promises.writeFile.call(void 0, absoluteFile, source, "utf8");
+  return file;
+}
+function resolveEntryExtension(entry) {
+  const ext = _path2.default.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 = (_nullishCoalesce(candidateCountByClass.get(className), () => ( 0))) + 1;
+    candidateCountByClass.set(className, nextCount);
+    runtimeSet.add(className);
+  }
+}
+function createBundleRuntimeClassSetManager(options = {}) {
+  const customExtractCandidates = options.extractCandidates;
+  const extractCandidates = _nullishCoalesce(customExtractCandidates, () => ( _tailwindcsspatch.extractValidCandidates));
+  const extractRawCandidates = _nullishCoalesce(options.extractRawCandidates, () => ( _tailwindcsspatch.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 _promises.rm.call(void 0, 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 = _optionalChain([match, 'optionalAccess', _50 => _50.rawCandidate]);
+      if (typeof candidate === "string" && candidate.length > 0) {
+        candidates.add(candidate);
+      }
+    }
+    return candidates;
+  }
+  async function sync(patcher, snapshot) {
+    const nextSignature = _nullishCoalesce(_chunk5KSBT6GUjs.getRuntimeClassSetSignature.call(void 0, 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 = _nullishCoalesce(options.tempRoot, () => ( _path2.default.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
   };
 }
 
@@ -1198,12 +1690,12 @@ function createRewriteCssImportsPlugins(options) {
   const { appType, weappTailwindcssDirPosix: weappTailwindcssDirPosix2 } = options;
   return [
     {
-      name: `${_chunkI4EOMKX2js.vitePluginName}:rewrite-css-imports`,
+      name: `${_chunkLYGLQCWIjs.vitePluginName}:rewrite-css-imports`,
       enforce: "pre",
       resolveId: {
         order: "pre",
         handler(id, importer) {
-          const replacement = _chunkG3G437UEjs.resolveTailwindcssImport.call(void 0, id, weappTailwindcssDirPosix2, {
+          const replacement = _chunk7LKMJZD2js.resolveTailwindcssImport.call(void 0, id, weappTailwindcssDirPosix2, {
             join: joinPosixPath,
             appType
           });
@@ -1222,7 +1714,7 @@ function createRewriteCssImportsPlugins(options) {
           if (!isCSSRequest(id)) {
             return null;
           }
-          const rewritten = _chunkG3G437UEjs.rewriteTailwindcssImportsInCode.call(void 0, code, weappTailwindcssDirPosix2, {
+          const rewritten = _chunk7LKMJZD2js.rewriteTailwindcssImportsInCode.call(void 0, code, weappTailwindcssDirPosix2, {
             join: joinPosixPath,
             appType
           });
@@ -1240,13 +1732,39 @@ function createRewriteCssImportsPlugins(options) {
 }
 
 // src/bundlers/vite/index.ts
-var debug = _chunkI4EOMKX2js.createDebug.call(void 0, );
-var weappTailwindcssPackageDir = _chunkG3G437UEjs.resolvePackageDir.call(void 0, "weapp-tailwindcss");
+var debug2 = _chunkLYGLQCWIjs.createDebug.call(void 0, );
+var weappTailwindcssPackageDir = _chunk7LKMJZD2js.resolvePackageDir.call(void 0, "weapp-tailwindcss");
 var weappTailwindcssDirPosix = slash(weappTailwindcssPackageDir);
+var PACKAGE_JSON_FILE = "package.json";
+function resolveImplicitTailwindcssBasedirFromViteRoot(root) {
+  const resolvedRoot = _path2.default.resolve(root);
+  if (!_fs.existsSync.call(void 0, resolvedRoot)) {
+    return resolvedRoot;
+  }
+  const searchRoots = [];
+  let current = resolvedRoot;
+  while (true) {
+    searchRoots.push(current);
+    const parent = _path2.default.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  const tailwindConfigPath = _chunk5KSBT6GUjs.findTailwindConfig.call(void 0, searchRoots);
+  if (tailwindConfigPath) {
+    return _path2.default.dirname(tailwindConfigPath);
+  }
+  const packageRoot = _chunk5KSBT6GUjs.findNearestPackageRoot.call(void 0, resolvedRoot);
+  if (packageRoot && _fs.existsSync.call(void 0, _path2.default.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;
-  const opts = _chunkI4EOMKX2js.getCompilerContext.call(void 0, options);
+  const opts = _chunkLYGLQCWIjs.getCompilerContext.call(void 0, options);
   const {
     disabled,
     customAttributes,
@@ -1260,7 +1778,7 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
     uniAppX,
     disabledDefaultTemplateHandler
   } = opts;
-  const disabledOptions = _chunkG3G437UEjs.resolveDisabledOptions.call(void 0, disabled);
+  const disabledOptions = _chunk7LKMJZD2js.resolveDisabledOptions.call(void 0, disabled);
   const tailwindcssMajorVersion = _nullishCoalesce(initialTwPatcher.majorVersion, () => ( 0));
   const shouldRewriteCssImports = opts.rewriteCssImports !== false && !disabledOptions.rewriteCssImports && (rewriteCssImportsSpecified || tailwindcssMajorVersion >= 4);
   const rewritePlugins = createRewriteCssImportsPlugins({
@@ -1271,8 +1789,8 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
   if (disabledOptions.plugin) {
     return rewritePlugins.length ? rewritePlugins : void 0;
   }
-  const customAttributesEntities = _chunkI4EOMKX2js.toCustomAttributesEntities.call(void 0, customAttributes);
-  const patchRecorderState = _chunkPXZUQ7RRjs.setupPatchRecorder.call(void 0, initialTwPatcher, opts.tailwindcssBasedir, {
+  const customAttributesEntities = _chunkLYGLQCWIjs.toCustomAttributesEntities.call(void 0, customAttributes);
+  const patchRecorderState = _chunkLYGLQCWIjs.setupPatchRecorder.call(void 0, initialTwPatcher, opts.tailwindcssBasedir, {
     source: "runtime",
     cwd: _nullishCoalesce(opts.tailwindcssBasedir, () => ( _process2.default.cwd()))
   });
@@ -1287,9 +1805,10 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
   let resolvedConfig;
   let runtimeRefreshSignature;
   let runtimeRefreshOptionsKey;
+  const bundleRuntimeClassSetManager = createBundleRuntimeClassSetManager();
   function resolveRuntimeRefreshOptions() {
-    const configPath = _optionalChain([runtimeState, 'access', _30 => _30.twPatcher, 'access', _31 => _31.options, 'optionalAccess', _32 => _32.tailwind, 'optionalAccess', _33 => _33.config]);
-    const signature = _chunkI4EOMKX2js.getRuntimeClassSetSignature.call(void 0, runtimeState.twPatcher);
+    const configPath = _optionalChain([_chunk5KSBT6GUjs.resolveTailwindcssOptions.call(void 0, runtimeState.twPatcher.options), 'optionalAccess', _51 => _51.config]);
+    const signature = _chunk5KSBT6GUjs.getRuntimeClassSetSignature.call(void 0, runtimeState.twPatcher);
     const optionsKey = JSON.stringify({
       appType,
       uniAppX: Boolean(uniAppX),
@@ -1310,12 +1829,12 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
   async function refreshRuntimeState(force) {
     const invalidation = resolveRuntimeRefreshOptions();
     const shouldRefresh = force || invalidation.changed;
-    const refreshed = await _chunkI4EOMKX2js.refreshTailwindRuntimeState.call(void 0, runtimeState, {
+    const refreshed = await _chunkLYGLQCWIjs.refreshTailwindRuntimeState.call(void 0, runtimeState, {
       force: shouldRefresh,
       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;
@@ -1331,7 +1850,7 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
     }
     if (forceRuntimeRefresh || !runtimeSetPromise) {
       const invalidation = resolveRuntimeRefreshOptions();
-      const task2 = _chunkI4EOMKX2js.collectRuntimeClassSet.call(void 0, runtimeState.twPatcher, {
+      const task2 = _chunkLYGLQCWIjs.collectRuntimeClassSet.call(void 0, runtimeState.twPatcher, {
         force: forceRuntimeRefresh || invalidation.changed,
         skipRefresh: forceRuntimeRefresh,
         clearCache: forceRuntimeRefresh || invalidation.changed
@@ -1348,6 +1867,46 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
       }
     }
   }
+  async function ensureBundleRuntimeClassSet(snapshot, forceRefresh = false) {
+    const forceRuntimeRefresh = forceRefresh || _process2.default.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 = _chunkLYGLQCWIjs.collectRuntimeClassSet.call(void 0, 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 = _chunkDYLQ6UOIjs.resolveUniUtsPlatform.call(void 0, );
@@ -1367,16 +1926,23 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
   const plugins = [
     ...rewritePlugins,
     {
-      name: `${_chunkI4EOMKX2js.vitePluginName}:post`,
+      name: `${_chunkLYGLQCWIjs.vitePluginName}:post`,
       enforce: "post",
       async configResolved(config) {
         resolvedConfig = config;
         const resolvedRoot = config.root ? _path2.default.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", _nullishCoalesce(previousBasedir, () => ( "undefined")), resolvedRoot);
-          await refreshRuntimeState(true);
+        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",
+              _nullishCoalesce(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 +1952,7 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
           ));
           if (idx > -1) {
             postcssPlugins.splice(idx, 1, _htmltransform2.default.call(void 0, ));
-            debug("remove postcss-html-transform plugin from vite config");
+            debug2("remove postcss-html-transform plugin from vite config");
           }
         }
       },
@@ -1394,7 +1960,8 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
         opts,
         runtimeState,
         ensureRuntimeClassSet,
-        debug,
+        ensureBundleRuntimeClassSet,
+        debug: debug2,
         getResolvedConfig
       })
     }