weapp-tailwindcss 5.0.13 → 5.1.0

package/dist/{vite-DjI09vVN.mjs → vite-CPO83EhA.mjs}

@@ -1,22 +1,21 @@
 import { resolveImplicitAppTypeFromViteRoot } from "./framework.mjs";
-import { D as hasTailwindRootDirectives, E as hasTailwindApplyDirective, N as parseImportRequest, O as hasTailwindSourceDirectives, P as removeTailwindSourceDirectives, Q as filterUnsupportedMiniProgramTailwindV4Candidates, T as hasLocalCssImport, Y as getTailwindV4IncrementalGenerateCacheStats, _ as resolveTailwindConfigEntriesFromCssCached, a as getTailwindV3IncrementalGenerateCacheStats, b as resolveViteTailwindV4CssDependencies, g as discoverTailwindV4CssEntries, gt as omitUndefined, h as resolveViteSourceScanEntries, it as resolveTailwindV4CssSourceBase, j as normalizeTailwindSourceForGenerator, k as normalizeTailwindConfigDirectives, lt as findTailwindConfig, m as createViteSourceScanMatcher, ot as createDebug, pt as findNearestPackageRoot, u as getRuntimeClassSetSignature, ut as resolveTailwindcssOptions, y as resolveTailwindV4EntriesFromCssCached, z as hasTailwindGeneratedCssMarkers } from "./v3-engine-C6eJ0YzK.mjs";
-import { i as normalizeWeappTailwindcssGeneratorOptions } from "./generator-ITLd7PTl.mjs";
-import { _ as collectRuntimeClassSet, a as vitePluginName, b as refreshTailwindRuntimeState, g as toCustomAttributesEntities, n as getCompilerContext, p as replaceWxml, t as shouldSkipJsTransform, v as createTailwindRuntimeReadyPromise } from "./precheck-CRI90iL1.mjs";
+import { A as removeTailwindSourceDirectives, C as hasTailwindRootDirectives, E as normalizeTailwindConfigDirectives, I as hasTailwindGeneratedCssMarkers, K as getTailwindV4IncrementalGenerateCacheStats, O as normalizeTailwindSourceForGenerator, S as hasTailwindNonRootGenerationDirectives, T as hasTailwindSourceDirectives, _ as resolveTailwindcssOptions, a as filterTailwindV4CssSourceRoots, b as hasLocalCssImport, ct as omitUndefined, d as normalizeCssEntries, f as findNearestPackageRoot, it as resolveTailwindV4CssSourceBase, k as parseImportRequest, o as hasConfiguredTailwindV4CssRoots, s as upsertTailwindV4CssSource, st as filterUnsupportedMiniProgramTailwindV4Candidates, u as isTailwindV4CssEntry, w as hasTailwindRootImportDirectives, x as hasTailwindApplyDirective } from "./v4-engine-CF9zt4Cw.mjs";
+import { a as resolveGeneratorRuntimeBranch, c as shouldUseNativeAppCssBranch, i as normalizeWeappTailwindcssGeneratorOptions, s as shouldUseMiniProgramCssBranch } from "./generator-Dc4qaPmT.mjs";
 import { o as resolveUniUtsPlatform } from "./utils-DodxWHGz.mjs";
-import { a as normalizeCssEntries, c as hasConfiguredTailwindV4CssRoots, i as resolveUniAppXOptions, l as upsertTailwindV4CssSource, r as isUniAppXEnabled } from "./tailwindcss-DTq3uYBK.mjs";
-import { _ as createCssSourceTraceCacheSignature, a as createTailwindV3DefaultExtractor, b as processCachedTask, c as validateCandidatesByGenerator, d as extractMarkedUserLayerComponentsCss, f as mergeMarkedUserLayerComponentsCss, g as annotateCssSourceTrace, i as isSourceCandidateRequest, l as pushConcurrentTaskFactories, o as createBundleRuntimeClassSetManager, r as createSourceCandidateCollector, s as generateCssByGenerator, t as createHmrTimingRecorder, u as runWithConcurrency, v as createCssTokenSourceMap } from "./hmr-timing-DQIP_8qP.mjs";
-import { S as toAbsoluteOutputPath, _ as slash, a as applyLinkedResults, b as normalizeOutputPathKey, c as hasBundlerGeneratedCssMarker, d as resolvePackageDir, f as resolvePluginDisabledState, g as normalizePath, h as isCSSRequest, i as createRuntimeAffectingSourceSignature, l as parseBundlerGeneratedCssMarkerBlocks, m as formatPostcssSourceMap, n as createBundleBuildState, o as createBundleModuleGraphOptions, p as cleanUrl, r as updateBundleBuildState, s as createBundlerGeneratedCssMarker, t as buildBundleSnapshot, u as stripBundlerGeneratedCssMarkers, v as isSourceStyleRequest, y as stripRequestQuery } from "./bundle-state-zQ2MrDdi.mjs";
+import { _ as collectRuntimeClassSet, b as refreshTailwindRuntimeState, c as shouldSkipJsTransform, g as toCustomAttributesEntities, i as vitePluginName, p as replaceWxml, t as getCompilerContext, v as createTailwindRuntimeReadyPromise, x as createDebug } from "./context-Mbzkek1q.mjs";
+import { _ as resolveViteTailwindV4CssDependencies, a as findTailwindConfig, f as createViteSourceScanMatcher, g as resolveTailwindV4EntriesFromCssCached, i as resolveUniAppXOptions, l as getRuntimeClassSetSignature, m as discoverTailwindV4CssEntries, p as resolveViteSourceScanEntries, r as isUniAppXEnabled } from "./tailwindcss-wyUHrfil.mjs";
+import { A as stripMiniProgramCssSpecificityPlaceholders, F as processCachedTask, M as createCssSourceTraceCacheSignature, N as createCssTokenSourceMap, O as hasMiniProgramCssSpecificityPlaceholders, _ as isPureLocalCssImportWrapper, a as isSourceCandidateRequest, d as validateCandidatesByGenerator, f as pushConcurrentTaskFactories, g as mergeMarkedUserLayerComponentsCss, h as extractMarkedUserLayerComponentsCss, j as annotateCssSourceTrace, m as runWithConcurrency, r as createSourceCandidateCollector, s as createBundleRuntimeClassSetManager, t as createHmrTimingRecorder } from "./hmr-timing-BXMLsF4b.mjs";
+import { A as isSourceStyleRequest, C as resolvePluginDisabledState, D as isHTMLRequest, E as isCSSRequest, M as normalizeOutputPathKey, O as normalizePath, P as toAbsoluteOutputPath, S as resolvePackageDir, T as formatPostcssSourceMap, _ as generateTailwindV4Css, a as createJsHashSalt, b as parseBundlerGeneratedCssMarkerBlocks, c as hasRuntimeAffectingSourceChanges, f as createBundleBuildState, g as createBundleModuleGraphOptions, h as applyLinkedResults, i as createCandidateSignature, j as stripRequestQuery, k as slash, l as summarizeStringDiff, m as createRuntimeAffectingSourceSignature, n as createScopedGeneratorCandidateSignature, o as createLinkedImpactSignature, p as updateBundleBuildState, r as createScopedGeneratorRuntime, s as getSnapshotHash, t as createSourceCandidateScanSignature, u as buildBundleSnapshot, v as createBundlerGeneratedCssMarker, w as cleanUrl, x as stripBundlerGeneratedCssMarkers, y as hasBundlerGeneratedCssMarker } from "./source-candidate-scan-signature-Cvb5z1ha.mjs";
 import { t as logger$1 } from "./logger-BNzxZbZj.mjs";
 import fs, { existsSync } from "node:fs";
 import path from "node:path";
 import process$1 from "node:process";
-import { containsCssAfterMinify, filterExistingCssRules, getPostcssPluginName, mergeCoveredCssRuleDeclarations, mergeMiniProgramPreflightRuleDeclarations, mergeMiniProgramThemeScopeRuleDeclarations, postcss, removeTailwindPostcssPlugins, resolveFilteredPostcssConfig } from "@weapp-tailwindcss/postcss";
+import { splitCandidateTokens } from "@tailwindcss-mangle/engine";
+import { containsCssAfterMinify, filterExistingCssRules, mergeCoveredCssRuleDeclarations, mergeMiniProgramPreflightRuleDeclarations, mergeMiniProgramThemeScopeRuleDeclarations, postcss, removeTailwindPostcssPlugins, resolveFilteredPostcssConfig } from "@weapp-tailwindcss/postcss";
 import { LRUCache } from "lru-cache";
-import { splitCandidateTokens } from "tailwindcss-patch";
-import { logger } from "@weapp-tailwindcss/logger";
 import { readFile } from "node:fs/promises";
 import { Buffer } from "node:buffer";
-import postcssHtmlTransform from "@weapp-tailwindcss/postcss/html-transform";
+import { logger } from "@weapp-tailwindcss/logger";
 import { parse } from "comment-json";
 //#region src/uni-app-x/harmony.ts
 function isUniAppXHarmonyOutDir(outDir) {
@@ -353,18 +352,13 @@ function findFirstStyleObjectDecl(source) {
 		varName
 	};
 }
-function resolveCssFallbackFiles(file) {
-	const files = [
-		"main.wxss",
-		"main.css",
-		"app.wxss",
-		"app.css"
-	];
-	if (file.startsWith("assets/") && file.endsWith(".js")) {
-		const withoutAssets = file.slice(7).replace(/\.js$/, "");
-		files.push(`${withoutAssets}.wxss`, `${withoutAssets}.css`);
-	}
-	return files;
+function resolveCssFallbackFiles(styleAssetFiles = []) {
+	const files = /* @__PURE__ */ new Set();
+	for (const assetFile of styleAssetFiles) if (assetFile) files.add(assetFile);
+	return [...files];
+}
+function resolveStyleAssetFilesForChunk(file, styleAssetFiles) {
+	return typeof styleAssetFiles === "function" ? styleAssetFiles(file) : styleAssetFiles;
 }
 function resolveSourceMapFiles(file) {
 	return [
@@ -374,7 +368,7 @@ function resolveSourceMapFiles(file) {
 	].filter((item) => typeof item === "string");
 }
 function createStyleValueFromBundleSources(file, _code, getBundleSource, options = {}) {
-	const cssStyles = mergeStyleValues(...[...options.cssSources ?? []].map((source) => source ? cssSourceToStyleValue(source) : void 0), ...resolveCssFallbackFiles(file).map((cssFile) => {
+	const cssStyles = mergeStyleValues(...[...options.cssSources ?? []].map((source) => source ? cssSourceToStyleValue(source) : void 0), ...resolveCssFallbackFiles(resolveStyleAssetFilesForChunk(file, options.styleAssetFiles)).map((cssFile) => {
 		const source = getBundleSource?.(cssFile);
 		return source ? cssSourceToStyleValue(source) : void 0;
 	}));
@@ -425,12 +419,15 @@ function injectUniAppXHarmonyGlobalStyles(file, code, getBundleSource, options =
 }
 function injectUniAppXHarmonyBundleStyles(bundle, options = {}) {
 	const getBundleSource = createUniAppXBundleAssetSourceGetter(bundle);
+	const styleAssetFilesByChunk = collectUniAppXBundleStyleAssetFilesByChunk(bundle);
+	const resolveStyleAssetFiles = typeof options.styleAssetFiles === "function" ? options.styleAssetFiles : (file) => [...options.styleAssetFiles ?? [], ...styleAssetFilesByChunk.get(file) ?? []];
 	let changed = false;
 	for (const [file, item] of Object.entries(bundle)) {
 		if (item.type !== "chunk" || !file.endsWith(".js")) continue;
 		const currentSource = item.code;
 		const nextSource = injectUniAppXHarmonyGlobalStyles(file, currentSource, getBundleSource, {
 			...options,
+			styleAssetFiles: resolveStyleAssetFiles,
 			mapSources: collectChunkMapSourcesContent(item)
 		});
 		if (nextSource !== currentSource) {
@@ -440,6 +437,41 @@ function injectUniAppXHarmonyBundleStyles(bundle, options = {}) {
 	}
 	return changed;
 }
+function collectUniAppXBundleStyleAssetFilesByChunk(bundle) {
+	const styleAssetFilesByChunk = /* @__PURE__ */ new Map();
+	const appStyleAssetFiles = /* @__PURE__ */ new Set();
+	const assetFiles = new Set(Object.entries(bundle).filter(([, item]) => item.type === "asset").map(([file]) => file).filter(isStyleAssetFile));
+	for (const [chunkFile, item] of Object.entries(bundle)) {
+		if (item.type !== "chunk") continue;
+		const chunk = item;
+		for (const cssFile of chunk.viteMetadata?.importedCss ?? []) {
+			if (!assetFiles.has(cssFile)) continue;
+			if (APP_JS_RE.test(chunk.fileName ?? chunkFile) || APP_JS_RE.test(chunkFile)) {
+				appStyleAssetFiles.add(cssFile);
+				continue;
+			}
+			let styleAssetFiles = styleAssetFilesByChunk.get(chunkFile);
+			if (!styleAssetFiles) {
+				styleAssetFiles = /* @__PURE__ */ new Set();
+				styleAssetFilesByChunk.set(chunkFile, styleAssetFiles);
+			}
+			styleAssetFiles.add(cssFile);
+		}
+	}
+	if (appStyleAssetFiles.size > 0) for (const [file, item] of Object.entries(bundle)) {
+		if (item.type !== "chunk" || !file.endsWith(".js") || APP_JS_RE.test(file)) continue;
+		let styleAssetFiles = styleAssetFilesByChunk.get(file);
+		if (!styleAssetFiles) {
+			styleAssetFiles = /* @__PURE__ */ new Set();
+			styleAssetFilesByChunk.set(file, styleAssetFiles);
+		}
+		for (const appStyleAssetFile of appStyleAssetFiles) styleAssetFiles.add(appStyleAssetFile);
+	}
+	return styleAssetFilesByChunk;
+}
+function isStyleAssetFile(file) {
+	return /\.(?:acss|css|jxss|qss|ttss|wxss)$/i.test(file);
+}
 function isUniAppXHarmonyBundle(bundle) {
 	for (const file of Object.keys(bundle)) if (HARMONY_BUNDLE_MARKER_FILES.has(file)) return true;
 	return false;
@@ -476,7 +508,7 @@ function resolveUniAppXStyleIsolationEnabled(root) {
 //#region src/uni-app-x/vite.ts
 let transformUVuePromise;
 function loadTransformUVue() {
-	transformUVuePromise ?? (transformUVuePromise = import("./transform-DfcEjsZF.mjs").then((mod) => mod.transformUVue));
+	transformUVuePromise ?? (transformUVuePromise = import("./transform-tExdt40m.mjs").then((mod) => mod.transformUVue));
 	return transformUVuePromise;
 }
 const preprocessorLangs = new Set([
@@ -775,25 +807,25 @@ function collectUnescapedDynamicCandidates(source, allowedCandidates) {
 	}
 	return [...matches];
 }
-function collectLegacyContainerCompatCandidates(sourceCandidates, candidates) {
-	if (candidates.has("container")) return candidates;
-	if (!sourceCandidates.has("container")) return candidates;
-	return new Set([...candidates, "container"]);
-}
 //#endregion
 //#region src/bundlers/vite/generate-bundle/configured-css-sources.ts
 function collectConfiguredTailwindV4CssSources(opts) {
-	const patcherCssSources = opts.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssSources ?? [];
-	return [...opts.tailwindcss?.v4?.cssSources ?? [], ...patcherCssSources];
+	const runtimeCssSources = opts.tailwindcssRuntimeOptions?.tailwindcss?.v4?.cssSources ?? [];
+	return filterTailwindV4CssSourceRoots([...opts.tailwindcss?.v4?.cssSources ?? [], ...runtimeCssSources]) ?? [];
 }
 function collectConfiguredTailwindV4CssSourceEntries(opts, fallbackBase) {
 	const entries = [];
+	const seen = /* @__PURE__ */ new Set();
 	for (const cssSource of collectConfiguredTailwindV4CssSources(opts)) {
 		if (typeof cssSource.css !== "string" || cssSource.css.length === 0) continue;
 		const base = resolveTailwindV4CssSourceBase(cssSource, fallbackBase);
 		const file = typeof cssSource.file === "string" && cssSource.file.length > 0 ? cssSource.file : path.join(base, "tailwind.css");
+		const resolvedFile = path.isAbsolute(file) ? path.resolve(file) : path.resolve(base, file);
+		const key = `${resolvedFile}\0${cssSource.css}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
 		entries.push({
-			file: path.isAbsolute(file) ? path.resolve(file) : path.resolve(base, file),
+			file: resolvedFile,
 			source: cssSource.css
 		});
 	}
@@ -890,8 +922,23 @@ function resolveStyleOutputExtensionFromMatcher(cssMatcher, stem) {
 	if (!cssMatcher || !stem) return;
 	return COMMON_MINI_PROGRAM_STYLE_OUTPUT_EXTENSIONS.find((extension) => cssMatcher(`${stem}${extension}`));
 }
+function resolveStyleOutputFileFromFiles(files, cssMatcher, stem) {
+	const cleanStem = normalizeOutputPathKey(stem);
+	const stemSuffix = `/${cleanStem}`;
+	const matchedFiles = /* @__PURE__ */ new Set();
+	for (const file of files ?? []) {
+		const cleanFile = normalizeOutputPathKey(file.replace(/[?#].*$/, ""));
+		if (!cssMatcher?.(cleanFile)) continue;
+		const extension = path.extname(cleanFile);
+		if (!extension || extension === ".css") continue;
+		const outputStem = cleanFile.slice(0, -extension.length);
+		const outputStemSuffix = `/${outputStem}`;
+		if (outputStem === cleanStem || outputStem.endsWith(stemSuffix) || cleanStem.endsWith(outputStemSuffix)) matchedFiles.add(cleanFile);
+	}
+	return matchedFiles.size === 1 ? [...matchedFiles][0] : void 0;
+}
 function resolveMiniProgramStyleOutputExtension(options = {}) {
-	return resolveStyleOutputExtensionFromFiles(options.files, options.cssMatcher, options.stem) ?? resolveStyleOutputExtensionFromMatcher(options.cssMatcher, options.stem) ?? normalizeStyleOutputExtension(options.fallback) ?? resolveStyleOutputExtensionFromFiles(options.files, options.cssMatcher) ?? FALLBACK_STYLE_OUTPUT_EXTENSION;
+	return resolveStyleOutputExtensionFromFiles(options.files, options.cssMatcher, options.stem) ?? resolveStyleOutputExtensionFromFiles(options.files, options.cssMatcher) ?? resolveStyleOutputExtensionFromMatcher(options.cssMatcher, options.stem) ?? normalizeStyleOutputExtension(options.fallback) ?? FALLBACK_STYLE_OUTPUT_EXTENSION;
 }
 function resolveReplayCssOutputFile(rootDir, file) {
 	const normalizedFile = normalizeOutputPathKey(path.isAbsolute(file) ? path.relative(rootDir, file) : file);
@@ -931,6 +978,21 @@ function resolveViteCssPipelineOutputFile(file, opts, rootDir, isWebGeneratorTar
 	if (!fallbackExtension && !SOURCE_STYLE_OUTPUT_EXT_RE.test(normalizedFile)) return normalizedFile;
 	return normalizedFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, fallbackExtension ?? FALLBACK_STYLE_OUTPUT_EXTENSION);
 }
+function resolveViteCssPipelineOutputFileFromSourceFile(sourceFile, opts, rootDir, isWebGeneratorTarget = false, preserveCssExtension = false, sourceRoot, styleOutputExtension, styleOutputFiles) {
+	const normalizedFile = resolveReplayCssOutputFileFromSourceRoot(rootDir, sourceFile, sourceRoot);
+	const cleanFile = normalizedFile.replace(/[?#].*$/, "");
+	if (isWebGeneratorTarget || preserveCssExtension || !CSS_SOURCE_OUTPUT_EXT_RE.test(cleanFile) || !isCSSRequest(normalizedFile)) return normalizedFile;
+	const stem = cleanFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, "");
+	const matchedStyleFile = resolveStyleOutputFileFromFiles(styleOutputFiles, opts.cssMatcher, stem);
+	if (matchedStyleFile) return matchedStyleFile;
+	const styleExtension = resolveStyleOutputExtensionFromFiles(styleOutputFiles, opts.cssMatcher, stem) ?? resolveMiniProgramStyleOutputExtension({
+		cssMatcher: opts.cssMatcher,
+		fallback: styleOutputExtension,
+		files: styleOutputFiles,
+		stem
+	}) ?? normalizeStyleOutputExtension(styleOutputExtension);
+	return normalizedFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, styleExtension);
+}
 function canProcessViteSourceStyleAsCss(source, file) {
 	if (SOURCE_STYLE_NON_CSS_SYNTAX_RE.test(source)) return false;
 	try {
@@ -1003,11 +1065,11 @@ function normalizeMatchedCssSourcePath(file) {
 	return path.resolve(file.replace(/[?#].*$/, ""));
 }
 function collectConfiguredCssEntries(opts) {
-	const patcherCssEntries = opts.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssEntries ?? [];
+	const runtimeCssEntries = opts.tailwindcssRuntimeOptions?.tailwindcss?.v4?.cssEntries ?? [];
 	return [
 		...opts.cssEntries ?? [],
 		...opts.tailwindcss?.v4?.cssEntries ?? [],
-		...patcherCssEntries ?? []
+		...runtimeCssEntries ?? []
 	].filter((entry) => typeof entry === "string" && entry.length > 0);
 }
 function collectCssConfigBaseCandidates(source, file, outputRoot, opts) {
@@ -1022,9 +1084,9 @@ function collectCssConfigBaseCandidates(source, file, outputRoot, opts) {
 	};
 	addCandidate(path.dirname(path.resolve(outputRoot, file.replace(/[?#].*$/, ""))));
 	const normalizedSource = normalizeCssSourceForCompare(source);
-	const patcherProjectRoot = typeof opts.tailwindcssPatcherOptions?.projectRoot === "string" ? opts.tailwindcssPatcherOptions.projectRoot : void 0;
-	const sourceBaseFallback = opts.tailwindcss?.v4?.base ?? patcherProjectRoot ?? opts.tailwindcssBasedir ?? outputRoot;
-	const sourceRoot = opts.tailwindcssBasedir ?? patcherProjectRoot;
+	const runtimeProjectRoot = typeof opts.tailwindcssRuntimeOptions?.projectRoot === "string" ? opts.tailwindcssRuntimeOptions.projectRoot : void 0;
+	const sourceBaseFallback = opts.tailwindcss?.v4?.base ?? runtimeProjectRoot ?? opts.tailwindcssBasedir ?? outputRoot;
+	const sourceRoot = opts.tailwindcssBasedir ?? runtimeProjectRoot;
 	const configuredCssEntries = collectConfiguredCssEntries(opts);
 	for (const cssEntry of configuredCssEntries) {
 		const resolvedCssEntry = path.resolve(cssEntry);
@@ -1064,7 +1126,7 @@ function createCssHandlerOptionsCache(options) {
 		const appType = options.getAppType();
 		const isMainChunk = options.mainCssChunkMatcher(file, appType);
 		const outputRoot = options.getOutputRoot?.();
-		const from = outputRoot ? path.resolve(outputRoot, file) : file;
+		const from = path.isAbsolute(file) ? file : outputRoot ? path.resolve(outputRoot, file) : file;
 		const extraOptions = options.getExtraOptions?.(file) ?? {};
 		const cacheKey = `${majorVersion ?? "unknown"}:${appType ?? "unknown"}:${isMainChunk ? "1" : "0"}:${outputRoot ?? ""}:${file}:${JSON.stringify(extraOptions)}`;
 		const cached = cssHandlerOptionsCache.get(cacheKey);
@@ -1122,7 +1184,7 @@ function createCssTransformShareScope(file, rawSource) {
 function createCssTransformShareScopeKey(opts, file, rawSource) {
 	if (opts.mainCssChunkMatcher(file, opts.appType)) return `main:${normalizeOutputPathKey(file)}`;
 	const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator);
-	if (hasTailwindGeneratedCssMarkers(rawSource) || hasTailwindSourceDirectives(rawSource, { importFallback: generatorOptions.importFallback }) || opts.twPatcher.majorVersion === 3 && (opts.cssEntries?.length ?? 0) > 1 && rawSource.includes("@tailwind")) return `source:${normalizeOutputPathKey(file)}`;
+	if (hasTailwindGeneratedCssMarkers(rawSource) || hasTailwindSourceDirectives(rawSource, { importFallback: generatorOptions.importFallback })) return `source:${normalizeOutputPathKey(file)}`;
 	return createCssTransformShareScope(file, rawSource);
 }
 function createCssRuntimeSignature(runtimeSignature, generatorCandidateSignature) {
@@ -1142,8 +1204,7 @@ function resolveGenerateBundleEnvFlags() {
 		forceRuntimeRefreshByEnv: process$1.env["WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH"] === "1",
 		disableDirtyOptimization: process$1.env["WEAPP_TW_VITE_DISABLE_DIRTY"] === "1",
 		disableJsPrecheck: process$1.env["WEAPP_TW_VITE_DISABLE_JS_PRECHECK"] === "1",
-		debugCssDiff: process$1.env["WEAPP_TW_VITE_DEBUG_CSS_DIFF"] === "1",
-		disableV3OxideSourceRuntime: process$1.env["WEAPP_TW_VITE_DISABLE_V3_OXIDE_RUNTIME"] === "1"
+		debugCssDiff: process$1.env["WEAPP_TW_VITE_DEBUG_CSS_DIFF"] === "1"
 	};
 }
 //#endregion
@@ -1615,8 +1676,14 @@ function extractSfcStyleSources(source) {
 function hasSfcStyleSources(source) {
 	return extractSfcStyleSources(source).length > 0;
 }
-function hasTailwindGenerationSource(source) {
-	return hasTailwindSourceDirectives(source, { importFallback: true }) || hasTailwindRootDirectives(source, { importFallback: true }) || hasTailwindApplyDirective(source);
+function hasTailwindGenerationSource(source, options = {}) {
+	const allowRootDirectives = options.allowRootDirectives !== false;
+	return hasTailwindNonRootGenerationDirectives(source, { importFallback: true }) || allowRootDirectives && hasTailwindSourceDirectives(source, { importFallback: true }) || allowRootDirectives && hasTailwindRootDirectives(source, { importFallback: true }) || hasTailwindApplyDirective(source);
+}
+function hasTailwindGenerationSourceForFile(file, source) {
+	if (isTailwindV4CssEntry(file)) return hasTailwindGenerationSource(source);
+	if (hasTailwindRootImportDirectives(source, { importFallback: true })) return false;
+	return hasTailwindGenerationSource(source, { allowRootDirectives: false });
 }
 async function resolveSfcStyleSourceFromOutputFile(outputFile, snapshot, outputRoot, sourceRoot, cssMatcher, getSfcSource, debug) {
 	const sourceFile = resolveSfcStyleFileFromSiblingChunk(outputFile, snapshot, outputRoot, sourceRoot, cssMatcher, debug);
@@ -1630,7 +1697,7 @@ async function resolveSfcStyleSourceFromOutputFile(outputFile, snapshot, outputR
 		return;
 	}
 	const rawSource = extractSfcStyleSources(source).join("\n");
-	if (!rawSource || !hasTailwindGenerationSource(rawSource)) {
+	if (!rawSource || !hasTailwindGenerationSourceForFile(sourceFile, rawSource)) {
 		debug("sfc style source infer skipped: no tailwind generation source for %s -> %s", outputFile, sourceFile);
 		return;
 	}
@@ -1737,8 +1804,8 @@ function resolveSourceStyleFileFromSiblingChunk(outputFile, snapshot, outputRoot
 function resolveSourceStyleSourceFromOutputFile(outputFile, snapshot, outputRoot, sourceRoot, getSourceStyleSource, getSourceStyleSources, configuredSourceEntries, debug) {
 	let sourceFile = resolveSourceStyleFileFromSiblingChunk(outputFile, snapshot, outputRoot, sourceRoot, debug);
 	let rawSource = sourceFile ? getSourceStyleSource?.(sourceFile) : void 0;
-	if (!rawSource || !hasTailwindGenerationSource(rawSource)) {
-		const scoredSources = [...getSourceStyleSources?.() ?? [], ...configuredSourceEntries ?? []].filter(([file, source]) => CSS_SOURCE_OUTPUT_EXT_RE.test(file) && hasTailwindGenerationSource(source)).map(([file, source]) => ({
+	if (!rawSource || !hasTailwindGenerationSourceForFile(sourceFile, rawSource)) {
+		const scoredSources = [...getSourceStyleSources?.() ?? [], ...configuredSourceEntries ?? []].filter(([file, source]) => CSS_SOURCE_OUTPUT_EXT_RE.test(file) && hasTailwindGenerationSourceForFile(file, source)).map(([file, source]) => ({
 			file,
 			source,
 			score: scoreMatchingStyleFileBase(outputFile, file, outputRoot, sourceRoot)
@@ -1752,7 +1819,7 @@ function resolveSourceStyleSourceFromOutputFile(outputFile, snapshot, outputRoot
 		}
 	}
 	if (!sourceFile || !rawSource) return;
-	if (!hasTailwindGenerationSource(rawSource)) {
+	if (!hasTailwindGenerationSourceForFile(sourceFile, rawSource)) {
 		debug("source style source infer skipped: no tailwind generation source for %s -> %s", outputFile, sourceFile);
 		return;
 	}
@@ -1837,10 +1904,10 @@ const CSS_OUTPUT_FILE_RE = /\.(?:css|wxss|acss|ttss|qss|jxss|tyss)(?:$|[?#])/i;
 function isCssOutputFile(file) {
 	return CSS_OUTPUT_FILE_RE.test(file);
 }
-function getAssetFile(bundleFile, asset) {
+function getAssetFile$1(bundleFile, asset) {
 	return asset.fileName || bundleFile;
 }
-function readAssetSource(asset) {
+function readAssetSource$2(asset) {
 	return typeof asset.source === "string" ? asset.source : asset.source.toString();
 }
 function clearAssetSource(asset) {
@@ -1920,9 +1987,9 @@ function collectRootStyleBundleCssSources(bundle, excludedFile) {
 	const excludedFileKey = normalizeOutputPathKey(excludedFile);
 	for (const [bundleFile, output] of Object.entries(bundle)) {
 		if (output.type !== "asset") continue;
-		const file = normalizeOutputPathKey(getAssetFile(bundleFile, output));
+		const file = normalizeOutputPathKey(getAssetFile$1(bundleFile, output));
 		if (file === excludedFileKey || !isRootStyleOutputFile(file)) continue;
-		const source = stripBundlerGeneratedCssMarkers(readAssetSource(output)).trim();
+		const source = stripBundlerGeneratedCssMarkers(readAssetSource$2(output)).trim();
 		if (source.length > 0) sources.push(source);
 	}
 	return sources;
@@ -1962,9 +2029,9 @@ function removeCssCoveredByRootStyleAssets(bundle, options) {
 	let updated = 0;
 	for (const [bundleFile, output] of Object.entries(bundle)) {
 		if (output.type !== "asset") continue;
-		const file = getAssetFile(bundleFile, output);
+		const file = getAssetFile$1(bundleFile, output);
 		if (!options.cssMatcher(file) || isRootStyleOutputFile(file) || options.isViteProcessedCssAsset?.(output, file) === true || options.subpackageRoots != null && isSubpackageOutputFile(file, options.subpackageRoots)) continue;
-		const rawSource = readAssetSource(output);
+		const rawSource = readAssetSource$2(output);
 		const nextCss = removeCssCoveredByRootStyleBundleSources(bundle, file, rawSource);
 		if (nextCss === rawSource) continue;
 		output.source = nextCss;
@@ -1985,8 +2052,28 @@ function isRootStyleOutputFile(file) {
 	const normalized = normalizeOutputPathKey(file.replace(/[?#].*$/, ""));
 	return isCssOutputFile(normalized) && !normalized.includes("/");
 }
+function isMiniProgramStyleOutputFile(file) {
+	return /\.(?:wxss|acss|ttss|qss|jxss|tyss)(?:$|[?#])/i.test(file);
+}
+function shouldPreserveMiniProgramImportShell(opts, file, css) {
+	return (opts.appType === "taro" || opts.appType === "uni-app-vite" || opts.appType === "uni-app-x") && isMiniProgramStyleOutputFile(file) && opts.cssMatcher(file) && isPureLocalCssImportWrapper(css);
+}
+function resolvePreservedImportShellInjectionTarget(opts, bundle, file, css) {
+	if (opts.appType !== "taro") return;
+	const importedStyleFiles = collectImportedStyleFiles(css, file);
+	if (importedStyleFiles.size !== 1) return;
+	const [importedFile] = importedStyleFiles;
+	if (!isRootStyleOutputFile(importedFile)) return;
+	for (const [bundleFile, output] of Object.entries(bundle)) {
+		if (output.type !== "asset") continue;
+		const outputFile = getAssetFile$1(bundleFile, output);
+		if (normalizeOutputPathKey(outputFile) === normalizeOutputPathKey(importedFile)) return outputFile;
+	}
+}
 function shouldUseCssAssetAsMainInjectionTarget(opts, file, records) {
 	const fileKey = normalizeOutputPathKey(file);
+	if (!isRootStyleOutputFile(file) && records.some((record) => typeof record.outputFile === "string" && normalizeOutputPathKey(record.outputFile) === fileKey)) return false;
+	if (!isRootStyleOutputFile(file)) return records.some((record) => record.injectIntoMain === true && typeof record.outputFile === "string" && normalizeOutputPathKey(record.outputFile) === fileKey);
 	if (records.some((record) => {
 		if (record.injectIntoMain !== true) return false;
 		return isRootStyleOutputFile(file) || typeof record.outputFile === "string" && normalizeOutputPathKey(record.outputFile) === fileKey;
@@ -1996,8 +2083,16 @@ function shouldUseCssAssetAsMainInjectionTarget(opts, file, records) {
 	return isRootStyleOutputFile(file) && records.some((record) => record.injectIntoMain === true);
 }
 function isViteProcessedCssResultImported(record, importedStyleFiles) {
-	const importedFileNames = new Set([...importedStyleFiles].map((file) => posix.posix.basename(file)));
-	return importedStyleFiles.has(normalizeOutputPathKey(record.file)) || typeof record.outputFile === "string" && (importedStyleFiles.has(normalizeOutputPathKey(record.outputFile)) || importedFileNames.has(posix.posix.basename(normalizeOutputPathKey(record.outputFile))));
+	return importedStyleFiles.has(normalizeOutputPathKey(record.file)) || typeof record.outputFile === "string" && importedStyleFiles.has(normalizeOutputPathKey(record.outputFile));
+}
+function isViteProcessedCssResultCoveredByImportedBundleAsset(record, importedStyleFiles, assetFiles) {
+	for (const candidate of [record.file, record.outputFile]) {
+		if (typeof candidate !== "string" || candidate.length === 0) continue;
+		const candidateKey = normalizeOutputPathKey(candidate);
+		if (!importedStyleFiles.has(candidateKey)) continue;
+		if (assetFiles.has(candidateKey)) return true;
+	}
+	return false;
 }
 function removeCssCoveredByImportedViteResults(css, importedCssSources) {
 	if (importedCssSources.length === 0) return css;
@@ -2011,9 +2106,9 @@ function collectImportedBundleCssSources(bundle, importedStyleFiles) {
 	const importedSources = [];
 	for (const [bundleFile, output] of Object.entries(bundle)) {
 		if (output.type !== "asset") continue;
-		const file = normalizeOutputPathKey(getAssetFile(bundleFile, output));
+		const file = normalizeOutputPathKey(getAssetFile$1(bundleFile, output));
 		if (!(importedStyleFiles.has(file) || !file.includes("/") && importedFileNames.has(posix.posix.basename(file)))) continue;
-		importedSources.push(readAssetSource(output));
+		importedSources.push(readAssetSource$2(output));
 	}
 	return importedSources;
 }
@@ -2021,7 +2116,7 @@ function collectBundleAssetFiles(bundle) {
 	const files = /* @__PURE__ */ new Set();
 	for (const [bundleFile, output] of Object.entries(bundle)) {
 		if (output.type !== "asset") continue;
-		files.add(normalizeOutputPathKey(getAssetFile(bundleFile, output)));
+		files.add(normalizeOutputPathKey(getAssetFile$1(bundleFile, output)));
 	}
 	return files;
 }
@@ -2044,14 +2139,19 @@ function isCoveredViteGeneratedSourceAsset(file, existingAssetFiles, resolveVite
 	const resolvedOutputFile = normalizeOutputPathKey(resolveViteProcessedCssOutputFile?.(file) ?? file);
 	return resolvedOutputFile !== normalizeOutputPathKey(file) && existingAssetFiles.has(resolvedOutputFile);
 }
+function isSourceRootPrefixedOutputFile(file, outputFile) {
+	const fileKey = normalizeOutputPathKey(file);
+	const outputFileKey = normalizeOutputPathKey(outputFile);
+	return fileKey !== outputFileKey && fileKey.endsWith(`/${outputFileKey}`);
+}
 function collectViteProcessedCssAssetResults(bundle, options) {
 	let collected = 0;
 	const existingAssetFiles = collectBundleAssetFiles(bundle);
 	for (const [bundleFile, output] of Object.entries(bundle)) {
 		if (output.type !== "asset") continue;
-		const file = getAssetFile(bundleFile, output);
+		const file = getAssetFile$1(bundleFile, output);
 		if (!isCssOutputFile(file) || !options.isViteProcessedCssAsset?.(output, file)) continue;
-		const rawSource = readAssetSource(output);
+		const rawSource = readAssetSource$2(output);
 		let nextCss = resolveViteProcessedCssAssetSource(file, rawSource, options.resolveViteProcessedCssOutputFile);
 		const singleMarkerFile = collectSingleViteGeneratedCssMarkerFile(rawSource);
 		if (singleMarkerFile && (options.subpackageRoots == null || !isSubpackageOutputFile(file, options.subpackageRoots)) && shouldFilterRootGeneratedCssMarkerForScopedAsset(file, singleMarkerFile, options.resolveViteProcessedCssOutputFile)) nextCss = removeCssCoveredByRootStyleBundleSources(bundle, file, nextCss);
@@ -2059,7 +2159,7 @@ function collectViteProcessedCssAssetResults(bundle, options) {
 		options.markCssAssetProcessed?.(output, file);
 		options.recordCssAssetResult?.(file, nextCss);
 		const resolvedOutputFile = options.resolveViteProcessedCssOutputFile?.(file) ?? file;
-		const shouldReplayIntoMainCss = options.opts != null && (options.opts.mainCssChunkMatcher(file, options.opts.appType) || normalizeOutputPathKey(resolvedOutputFile) !== normalizeOutputPathKey(file) && (isRootStyleOutputFile(file) || posix.posix.basename(normalizeOutputPathKey(file.replace(/[?#].*$/, ""))) === posix.posix.basename(normalizeOutputPathKey(resolvedOutputFile.replace(/[?#].*$/, "")))) && options.opts.mainCssChunkMatcher(resolvedOutputFile, options.opts.appType));
+		const shouldReplayIntoMainCss = options.opts != null && (isRootStyleOutputFile(file) && options.opts.mainCssChunkMatcher(file, options.opts.appType) || isSourceRootPrefixedOutputFile(file, resolvedOutputFile) && isRootStyleOutputFile(resolvedOutputFile) && options.opts.mainCssChunkMatcher(resolvedOutputFile, options.opts.appType));
 		options.recordViteProcessedCssAssetResult?.(file, nextCss, {
 			injectIntoMain: shouldReplayIntoMainCss || void 0,
 			outputFile: resolvedOutputFile
@@ -2104,25 +2204,48 @@ function injectViteProcessedCssIntoMainCssAssets(bundle, options) {
 		};
 	}).filter((record) => record.css.length > 0);
 	let injected = 0;
-	for (const [bundleFile, output] of Object.entries(bundle)) {
+	for (const [bundleFile, bundleOutput] of Object.entries(bundle)) {
+		let output = bundleOutput;
 		if (output.type !== "asset") continue;
-		const file = getAssetFile(bundleFile, output);
+		let file = getAssetFile$1(bundleFile, output);
 		if (!options.opts.cssMatcher(file) || !shouldUseCssAssetAsMainInjectionTarget(options.opts, file, viteCssResults)) continue;
+		let originalSource = readAssetSource$2(output);
+		if (shouldPreserveMiniProgramImportShell(options.opts, file, originalSource)) {
+			const importedTargetFile = resolvePreservedImportShellInjectionTarget(options.opts, bundle, file, originalSource);
+			if (typeof importedTargetFile === "string") {
+				options.debug?.("preserve mini-program css import shell asset: %s -> %s", file, importedTargetFile);
+				const importedOutput = Object.entries(bundle).find(([candidateFile, candidate]) => candidate.type === "asset" && normalizeOutputPathKey(getAssetFile$1(candidateFile, candidate)) === normalizeOutputPathKey(importedTargetFile))?.[1];
+				if (importedOutput?.type === "asset") {
+					output = importedOutput;
+					file = importedTargetFile;
+					originalSource = readAssetSource$2(output);
+				} else continue;
+			} else {
+				options.debug?.("preserve mini-program css import shell asset: %s", file);
+				continue;
+			}
+		}
+		const fileKey = normalizeOutputPathKey(file);
 		const mainFileKey = normalizeOutputPathKey(file);
-		const originalSource = readAssetSource(output);
 		let nextCss = removeTailwindEntryDirectivesFromCss(originalSource);
 		const importedStyleFiles = collectImportedStyleFiles(nextCss, file);
 		const importedBundleCssSources = collectImportedBundleCssSources(bundle, importedStyleFiles);
 		nextCss = removeCssCoveredByImportedViteResults(nextCss, importedBundleCssSources);
 		const importedViteCssResults = viteCssResults.filter((record) => isViteProcessedCssResultImported(record, importedStyleFiles));
-		const importedCssSources = [...importedBundleCssSources, ...importedViteCssResults.map((record) => record.css)];
-		nextCss = removeCssCoveredByImportedViteResults(nextCss, importedViteCssResults.map((record) => record.css));
+		const bundleAssetFiles = collectBundleAssetFiles(bundle);
+		const uncoveredImportedViteCssResults = importedViteCssResults.filter((record) => !isViteProcessedCssResultCoveredByImportedBundleAsset(record, importedStyleFiles, bundleAssetFiles));
+		const importedCssSources = [...importedBundleCssSources, ...uncoveredImportedViteCssResults.map((record) => record.css)];
+		nextCss = removeCssCoveredByImportedViteResults(nextCss, uncoveredImportedViteCssResults.map((record) => record.css));
 		for (const record of viteCssResults) {
+			if (!isRootStyleOutputFile(file)) {
+				if (typeof record.outputFile !== "string" || normalizeOutputPathKey(record.outputFile) !== fileKey) continue;
+			}
 			if (!shouldInjectViteProcessedCssResult(options.opts, mainFileKey, record.file, record)) continue;
 			if (isViteProcessedCssResultImported(record, importedStyleFiles)) continue;
 			let css = stripBundlerGeneratedCssMarkers(record.css).trim();
 			css = removeCssCoveredByImportedViteResults(css, importedCssSources).trim();
 			if (css.length === 0) continue;
+			if (containsCssAfterMinify(nextCss, css) || filterExistingCssRules(nextCss, css).length === 0) continue;
 			const mergedLayerCss = mergeMarkedUserLayerComponentsCss(nextCss, css);
 			if (mergedLayerCss.merged) {
 				nextCss = mergedLayerCss.css;
@@ -2163,9 +2286,10 @@ function injectViteProcessedCssIntoMainCssAssets(bundle, options) {
 			const recordFileKey = normalizeOutputPathKey(record.file);
 			for (const [candidateFile, candidateOutput] of Object.entries(bundle)) {
 				if (candidateOutput.type !== "asset") continue;
-				const candidateKey = normalizeOutputPathKey(getAssetFile(candidateFile, candidateOutput));
+				const candidateKey = normalizeOutputPathKey(getAssetFile$1(candidateFile, candidateOutput));
 				const isRecordFile = candidateKey === recordFileKey;
-				const isProcessedSource = readAssetSource(candidateOutput).trim() === record.css.trim();
+				const candidateSource = readAssetSource$2(candidateOutput).trim();
+				const isProcessedSource = candidateSource === record.css.trim() || candidateSource.length > 0 && containsCssAfterMinify(nextCss, candidateSource);
 				if (!isRecordFile && !isProcessedSource || candidateKey === normalizeOutputPathKey(file)) continue;
 				clearAssetSource(candidateOutput);
 				options.debug?.("remove injected vite-processed source css asset: %s -> %s", candidateKey, file);
@@ -2187,31 +2311,84 @@ function normalizeBundleFileNameKeysForTest(bundle) {
 	}
 }
 //#endregion
+//#region src/bundlers/vite/generate-bundle/final-css-assets.ts
+function readAssetSource$1(output) {
+	return typeof output.source === "string" ? output.source : output.source.toString();
+}
+function shouldFinalizeMiniProgramCssAsset(source) {
+	return source.includes(":hover") || source.includes("does-not-exist") || hasMiniProgramCssSpecificityPlaceholders(source);
+}
+async function finalizeMiniProgramCssAssets(bundle, options) {
+	if (options.isWebGeneratorTarget) return 0;
+	let updated = 0;
+	for (const [bundleFile, output] of Object.entries(bundle)) {
+		if (output.type !== "asset") continue;
+		const file = output.fileName || bundleFile;
+		if (!options.cssMatcher(file)) continue;
+		const rawSource = readAssetSource$1(output);
+		if (rawSource.trim().length === 0) continue;
+		if (options.lastCssResultByFile?.has(file)) {
+			const outputCss = stripMiniProgramCssSpecificityPlaceholders(rawSource);
+			if (outputCss !== rawSource) {
+				output.source = outputCss;
+				options.recordCssAssetResult?.(file, outputCss);
+				options.onUpdate(file, rawSource, outputCss);
+				options.debug?.("strip mini-program css specificity placeholders: %s bytes=%d", file, outputCss.length);
+				updated++;
+			}
+			continue;
+		}
+		if (!shouldFinalizeMiniProgramCssAsset(rawSource)) continue;
+		const cssHandlerOptions = options.getCssHandlerOptions(file);
+		const { css } = await options.styleHandler(rawSource, {
+			...cssHandlerOptions,
+			autoprefixer: false,
+			cssOptions: {
+				...cssHandlerOptions.cssOptions ?? {},
+				autoprefixer: false,
+				cssPresetEnv: false
+			},
+			cssPresetEnv: false
+		});
+		const outputCss = stripMiniProgramCssSpecificityPlaceholders(css);
+		if (outputCss === rawSource) continue;
+		output.source = outputCss;
+		options.recordCssAssetResult?.(file, outputCss);
+		options.onUpdate(file, rawSource, outputCss);
+		options.debug?.("finalize mini-program css asset: %s bytes=%d", file, outputCss.length);
+		updated++;
+	}
+	return updated;
+}
+//#endregion
 //#region src/bundlers/vite/generate-bundle/memory-debug.ts
-function toMb(bytes) {
+function toMb$2(bytes) {
 	return Math.round(bytes / 1024 / 1024);
 }
-function summarizeStringMapCache(map) {
+function summarizeStringMapCache$1(map) {
 	let bytes = 0;
 	for (const value of map.values()) bytes += value.length;
 	return {
 		bytes,
-		mb: toMb(bytes),
+		mb: toMb$2(bytes),
 		size: map.size
 	};
 }
 function resolveViteMemoryDebugStats(context) {
 	if (process$1.env["WEAPP_TW_HMR_MEMORY_DEBUG"] !== "1") return;
 	const memory = process$1.memoryUsage();
+	const processCacheInstanceSize = context.cache.instance.size;
+	const processCacheHashMapSize = context.cache.hashMap.size;
 	return {
 		phase: context.phase,
 		mode: context.useIncrementalMode ? "incremental" : "full",
+		bundle: { hasOmittedKnownFiles: context.hasOmittedKnownFiles },
 		process: {
-			rssMb: toMb(memory.rss),
-			heapTotalMb: toMb(memory.heapTotal),
-			heapUsedMb: toMb(memory.heapUsed),
-			externalMb: toMb(memory.external),
-			arrayBuffersMb: toMb(memory.arrayBuffers)
+			rssMb: toMb$2(memory.rss),
+			heapTotalMb: toMb$2(memory.heapTotal),
+			heapUsedMb: toMb$2(memory.heapUsed),
+			externalMb: toMb$2(memory.external),
+			arrayBuffersMb: toMb$2(memory.arrayBuffers)
 		},
 		runtime: {
 			sourceCandidates: context.sourceCandidatesSize,
@@ -2220,19 +2397,21 @@ function resolveViteMemoryDebugStats(context) {
 			generatorRuntime: context.generatorRuntimeSize
 		},
 		processCache: {
-			instance: context.cache.instance.size,
-			hashMap: context.cache.hashMap.size,
+			instance: processCacheInstanceSize,
+			hashMap: processCacheHashMapSize,
 			activeCacheKeys: context.activeProcessCacheKeys.size,
-			activeHashKeys: context.activeProcessHashKeys.size
+			activeHashKeys: context.activeProcessHashKeys.size,
+			staleCacheKeys: Math.max(0, processCacheInstanceSize - context.activeProcessCacheKeys.size),
+			staleHashKeys: Math.max(0, processCacheHashMapSize - context.activeProcessHashKeys.size),
+			pruned: context.processCachePruned,
+			pruneSkipped: !context.processCachePruned,
+			...context.processCachePruneSkipReason ? { pruneSkipReason: context.processCachePruneSkipReason } : {}
 		},
 		viteCss: {
 			...context.getViteCssCacheStats?.(),
-			lastCssResultByFile: summarizeStringMapCache(context.lastCssResultByFile)
+			lastCssResultByFile: summarizeStringMapCache$1(context.lastCssResultByFile)
 		},
-		tailwind: {
-			v3: getTailwindV3IncrementalGenerateCacheStats(),
-			v4: getTailwindV4IncrementalGenerateCacheStats()
-		}
+		tailwind: { v4: getTailwindV4IncrementalGenerateCacheStats() }
 	};
 }
 //#endregion
@@ -2281,12 +2460,13 @@ async function handleUniAppXPostCssTasks(options) {
 	if (isHarmonyAppStyleTarget && applyUtilities.size > 0 && applyStyleSources.length > 0) {
 		const outputFile = "uni-app-x-harmony-apply.css";
 		const cssHandlerOptions = getCssHandlerOptions(outputFile);
-		const generated = await generateCssByGenerator({
+		const generated = await generateTailwindV4Css({
 			opts,
 			runtimeState,
 			runtime: new Set([...generatorRuntime, ...applyUtilities]),
 			rawSource: createUniAppXHarmonyApplyGeneratorSource(applyStyleSources, applyUtilities),
 			file: outputFile,
+			outputFile,
 			cssHandlerOptions,
 			cssUserHandlerOptions: {
 				...cssHandlerOptions,
@@ -2317,10 +2497,10 @@ async function handleUniAppXPostCssTasks(options) {
 //#endregion
 //#region src/bundlers/vite/generate-bundle/vite-css-cache.ts
 const VITE_LAST_CSS_RESULT_CACHE_MAX = 64;
-function resolveViteCssTaskConcurrency(useIncrementalMode) {
+function resolveViteCssTaskConcurrency(_useIncrementalMode, _majorVersion) {
 	const configured = Number.parseInt(process$1.env["WEAPP_TW_VITE_CSS_CONCURRENCY"] ?? "", 10);
 	if (Number.isFinite(configured) && configured > 0) return configured;
-	return useIncrementalMode ? 1 : 2;
+	return 1;
 }
 function normalizeViteCssCacheKey(file) {
 	return normalizeOutputPathKey(file);
@@ -2361,10 +2541,83 @@ function pruneLastCssResults(resultByFile, sourceHashByFile, activeFiles) {
 }
 //#endregion
 //#region src/bundlers/vite/generate-bundle/finalize.ts
+function readAssetSource(asset) {
+	return typeof asset.source === "string" ? asset.source : asset.source.toString();
+}
+function getAssetFile(bundleFile, asset) {
+	return asset.fileName || bundleFile;
+}
+function isRootMiniProgramStyleOutputFile$1(file) {
+	const normalized = normalizeOutputPathKey(file.replace(/[?#].*$/, ""));
+	return !normalized.includes("/") && /\.(?:wxss|acss|ttss|qss|jxss|tyss)$/i.test(normalized);
+}
+function createRelativeCssImportRequest$1(targetFile, importedFile) {
+	const normalizedTargetFile = normalizeOutputPathKey(targetFile.replace(/[?#].*$/, ""));
+	const normalizedImportedFile = normalizeOutputPathKey(importedFile.replace(/[?#].*$/, ""));
+	const targetDir = path.posix.dirname(normalizedTargetFile);
+	const baseDir = targetDir === "." ? "" : targetDir;
+	const relative = path.posix.relative(baseDir, normalizedImportedFile);
+	return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function createCssImportShell$1(targetFile, importedFile) {
+	return `@import "${createRelativeCssImportRequest$1(targetFile, importedFile)}";\n`;
+}
+function resolveRootMiniProgramOriginStyleFile(file) {
+	const normalized = normalizeOutputPathKey(file.replace(/[?#].*$/, ""));
+	if (!isRootMiniProgramStyleOutputFile$1(normalized)) return;
+	if (/(?:^|\/)[^/]+-origin\.[^.]+$/i.test(normalized)) return;
+	return normalized.replace(/(\.[^.]+)$/, "-origin$1");
+}
+function resolveSingleCssImportOutputFile(targetFile, css) {
+	let importedFile;
+	try {
+		postcss.parse(css).walkAtRules("import", (atRule) => {
+			if (importedFile !== void 0) return;
+			const request = parseImportRequest(atRule.params);
+			if (!request || /^(?:https?:)?\/\//i.test(request) || request.startsWith("data:")) return;
+			const cleanRequest = request.replace(/[?#].*$/, "");
+			if (!/\.(?:css|wxss|acss|ttss|qss|jxss|tyss)$/i.test(cleanRequest)) return;
+			const targetDir = path.posix.dirname(normalizeOutputPathKey(targetFile));
+			importedFile = normalizeOutputPathKey(path.posix.join(targetDir === "." ? "" : targetDir, cleanRequest));
+		});
+	} catch {}
+	return importedFile;
+}
+function normalizeTaroRootImportShellAssets(bundle, options) {
+	if (options.appType !== "taro") return 0;
+	let updated = 0;
+	for (const [rootBundleFile, rootOutput] of Object.entries(bundle)) {
+		if (rootOutput.type !== "asset") continue;
+		const rootFile = getAssetFile(rootBundleFile, rootOutput);
+		if (!isRootMiniProgramStyleOutputFile$1(rootFile) || !options.cssMatcher(rootFile)) continue;
+		const originFile = resolveRootMiniProgramOriginStyleFile(rootFile);
+		if (!originFile || !options.cssMatcher(originFile)) continue;
+		const originOutput = Object.entries(bundle).find(([bundleFile, output]) => output.type === "asset" && normalizeOutputPathKey(getAssetFile(bundleFile, output)) === normalizeOutputPathKey(originFile))?.[1];
+		if (originOutput?.type !== "asset") continue;
+		const rootSource = readAssetSource(rootOutput);
+		if (isPureLocalCssImportWrapper(rootSource)) continue;
+		const originSource = readAssetSource(originOutput);
+		if (isPureLocalCssImportWrapper(originSource)) {
+			const importedFile = resolveSingleCssImportOutputFile(originFile, originSource);
+			if (importedFile && normalizeOutputPathKey(importedFile) !== normalizeOutputPathKey(rootFile)) continue;
+		} else if (originSource.trim().length > 0 && originSource.trim() !== rootSource.trim()) continue;
+		const nextRootSource = createCssImportShell$1(rootFile, originFile);
+		if (rootSource === nextRootSource) continue;
+		rootOutput.source = nextRootSource;
+		originOutput.source = rootSource;
+		options.recordCssAssetResult?.(rootFile, nextRootSource);
+		options.recordCssAssetResult?.(originFile, rootSource);
+		options.onUpdate?.(rootFile, rootSource, nextRootSource);
+		options.onUpdate?.(originFile, originSource, rootSource);
+		options.debug("normalize taro root css import shell: %s -> %s", rootFile, originFile);
+		updated++;
+	}
+	return updated;
+}
 async function finalizeGenerateBundle(options) {
 	const { activeProcessCacheKeys, activeProcessHashKeys, activeViteCssCacheFiles, bundle, bundleFiles, cache, cssTaskFactories, debug, defaultStyleOutputExtension, formatIteration, generatorCandidateSignature, generatorRuntime, getCssHandlerOptions, getSourceCandidateSourcesForEntries, getSourceCandidatesForEntries, getViteCssCacheStats, getViteProcessedCssAssetResults, hmrTimingRecorder, hmrTimingStartedAt, isHarmonyAppStyleTarget, isNativeAppStyleTarget, isViteProcessedCssAsset, isWebGeneratorTarget, lastCssResultByFile, lastCssSourceHashByFile, linkedByEntry, markCssAssetProcessed, metrics, onEnd, onUpdate, opts, pendingLinkedUpdates, pruneViteCssCaches, recordCssAssetResult, recordTimingDetail, recordViteProcessedCssAssetResult, rootDir, runtime, runtimeState, shouldPreserveAppCssExtension, snapshot, sourceCandidates, sourceRoot, state, styleHandler, tasks, timingDetails, transformRuntime, useIncrementalMode } = options;
 	if (cssTaskFactories.length > 0) {
-		const cssConcurrency = resolveViteCssTaskConcurrency(useIncrementalMode);
+		const cssConcurrency = resolveViteCssTaskConcurrency(useIncrementalMode, runtimeState.tailwindRuntime.majorVersion);
 		tasks.push(runWithConcurrency(cssTaskFactories, cssConcurrency).then(() => void 0));
 	}
 	const tasksStart = performance.now();
@@ -2402,9 +2655,10 @@ async function finalizeGenerateBundle(options) {
 			getViteProcessedCssAssetResults,
 			markCssAssetProcessed,
 			recordCssAssetResult,
-			shouldRemoveInjectedSourceAsset: (_targetFile, record) => {
-				if (record.injectIntoMain !== true || typeof record.outputFile !== "string") return false;
-				return normalizeOutputPathKey(record.file) !== normalizeOutputPathKey(record.outputFile);
+			shouldRemoveInjectedSourceAsset: (targetFile, record) => {
+				if (record.injectIntoMain === false) return false;
+				const targetFileKey = normalizeOutputPathKey(targetFile);
+				return normalizeOutputPathKey(record.file) !== targetFileKey;
 			},
 			debug,
 			onUpdate
@@ -2415,6 +2669,13 @@ async function finalizeGenerateBundle(options) {
 		if (injectUniAppXHarmonyBundleStyles(bundle, { cssSources: [...getViteProcessedCssAssetResults?.() ?? []].map(([, record]) => typeof record === "string" ? record : record.css) })) debug("uni-app-x harmony bundle styles inject after css assets");
 		syncViteProcessedCssIntoMainCssAssets();
 	}
+	normalizeTaroRootImportShellAssets(bundle, {
+		appType: opts.appType,
+		cssMatcher: opts.cssMatcher,
+		debug,
+		onUpdate,
+		recordCssAssetResult
+	});
 	normalizeBundleFileNameKeysForTest(bundle);
 	removeCssCoveredByRootStyleAssets(bundle, {
 		cssMatcher: opts.cssMatcher,
@@ -2424,18 +2685,33 @@ async function finalizeGenerateBundle(options) {
 		recordCssAssetResult,
 		subpackageRoots: collectMiniProgramSubpackageRoots(bundle)
 	});
+	await finalizeMiniProgramCssAssets(bundle, {
+		cssMatcher: opts.cssMatcher,
+		debug,
+		getCssHandlerOptions,
+		isWebGeneratorTarget,
+		lastCssResultByFile,
+		onUpdate,
+		recordCssAssetResult,
+		styleHandler
+	});
 	const stateUpdateStart = performance.now();
 	updateBundleBuildState(state, snapshot, useIncrementalMode ? linkedByEntry ?? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map(), { incremental: useIncrementalMode });
 	state.generatorCandidateSignature = generatorCandidateSignature;
-	if (useIncrementalMode && !snapshot.hasOmittedKnownFiles) cache.prune?.({
+	const shouldPruneTransientCaches = !snapshot.hasOmittedKnownFiles;
+	const processCachePruned = useIncrementalMode && shouldPruneTransientCaches && typeof cache.prune === "function";
+	const processCachePruneSkipReason = processCachePruned ? void 0 : !useIncrementalMode ? "full-mode" : !shouldPruneTransientCaches ? "omitted-known-files" : "cache-prune-unavailable";
+	if (processCachePruned) cache.prune?.({
 		cacheKeys: activeProcessCacheKeys,
 		hashKeys: activeProcessHashKeys
 	});
-	pruneLastCssResults(lastCssResultByFile, lastCssSourceHashByFile, activeViteCssCacheFiles);
-	pruneViteCssCaches?.({
-		activeFiles: activeViteCssCacheFiles,
-		activeKnownSfcFiles: new Set([...snapshot.sourceHashByFile.keys(), ...snapshot.entries.map((entry) => entry.file)])
-	});
+	if (shouldPruneTransientCaches) {
+		pruneLastCssResults(lastCssResultByFile, lastCssSourceHashByFile, activeViteCssCacheFiles);
+		pruneViteCssCaches?.({
+			activeFiles: activeViteCssCacheFiles,
+			activeKnownSfcFiles: new Set([...snapshot.sourceHashByFile.keys(), ...snapshot.entries.map((entry) => entry.file)])
+		});
+	}
 	recordTimingDetail("state.update", stateUpdateStart);
 	debug("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)", formatIteration, formatMs(metrics.runtimeSet), metrics.html.total, metrics.html.transformed, metrics.html.cacheHits, formatCacheHitRate(metrics.html), formatMs(metrics.html.elapsed), metrics.js.total, metrics.js.transformed, metrics.js.cacheHits, formatCacheHitRate(metrics.js), formatMs(metrics.js.elapsed), metrics.css.total, metrics.css.transformed, metrics.css.cacheHits, formatCacheHitRate(metrics.css), formatMs(metrics.css.elapsed));
 	if (hmrTimingRecorder) {
@@ -2447,8 +2723,11 @@ async function finalizeGenerateBundle(options) {
 				cache,
 				generatorRuntimeSize: generatorRuntime.size,
 				getViteCssCacheStats,
+				hasOmittedKnownFiles: snapshot.hasOmittedKnownFiles,
 				lastCssResultByFile,
 				phase: "generateBundle",
+				processCachePruned,
+				processCachePruneSkipReason,
 				runtimeSize: runtime.size,
 				sourceCandidatesSize: sourceCandidates.size,
 				transformRuntimeSize: transformRuntime.size,
@@ -2475,6 +2754,7 @@ function resolveUniAppXJsTransformEnabled(uniAppX) {
 function createJsHandlerOptionsFactory(options) {
 	return (absoluteFilename, extra) => ({
 		...extra,
+		generateMap: false,
 		filename: absoluteFilename,
 		tailwindcssMajorVersion: options.getMajorVersion(),
 		moduleGraph: options.moduleGraph,
@@ -2514,54 +2794,6 @@ function collectLinkedFileNames(linked, getJsEntry, linkedSet) {
 	}
 }
 //#endregion
-//#region src/bundlers/vite/generate-bundle/signatures.ts
-function summarizeStringDiff(previous, next) {
-	if (previous === next) return "same";
-	const previousLength = previous.length;
-	const nextLength = next.length;
-	const minLength = Math.min(previousLength, nextLength);
-	let prefixLength = 0;
-	while (prefixLength < minLength && previous.charCodeAt(prefixLength) === next.charCodeAt(prefixLength)) prefixLength += 1;
-	let previousSuffixCursor = previousLength - 1;
-	let nextSuffixCursor = nextLength - 1;
-	while (previousSuffixCursor >= prefixLength && nextSuffixCursor >= prefixLength && previous.charCodeAt(previousSuffixCursor) === next.charCodeAt(nextSuffixCursor)) {
-		previousSuffixCursor -= 1;
-		nextSuffixCursor -= 1;
-	}
-	const previousChangedLength = previousSuffixCursor >= prefixLength ? previousSuffixCursor - prefixLength + 1 : 0;
-	const nextChangedLength = nextSuffixCursor >= prefixLength ? nextSuffixCursor - prefixLength + 1 : 0;
-	return `changed@${prefixLength} old=${previousChangedLength} new=${nextChangedLength} len=${previousLength}->${nextLength}`;
-}
-function createLinkedImpactSignature(entry, linkedImpactsByEntry, sourceHashByFile) {
-	const changedLinkedFiles = linkedImpactsByEntry.get(entry);
-	if (!changedLinkedFiles || changedLinkedFiles.size === 0) return;
-	return [...changedLinkedFiles].sort().map((file) => {
-		return `${file}:${sourceHashByFile.get(file) ?? "missing"}`;
-	}).join(",");
-}
-function createJsHashSalt(runtimeSignature, linkedImpactSignature) {
-	if (!linkedImpactSignature) return runtimeSignature;
-	return `${runtimeSignature}:linked:${linkedImpactSignature}`;
-}
-function createStableTextSignature(input) {
-	let hash = 2166136261;
-	for (let i = 0; i < input.length; i++) {
-		hash ^= input.charCodeAt(i);
-		hash = Math.imul(hash, 16777619);
-	}
-	return (hash >>> 0).toString(36);
-}
-function createCandidateSignature(candidates) {
-	if (candidates.size === 0) return "empty";
-	return createStableTextSignature([...candidates].sort().join("\n"));
-}
-function getSnapshotHash(snapshotMap, file, fallback) {
-	return snapshotMap.get(file) ?? fallback;
-}
-function hasRuntimeAffectingSourceChanges(changedByType) {
-	return changedByType.html.size > 0 || changedByType.js.size > 0;
-}
-//#endregion
 //#region src/bundlers/vite/generate-bundle/js-processing.ts
 function processJsBundleEntry(options) {
 	const { applyLinkedUpdates, bundle, cache, createHandlerOptions, debug, disableJsPrecheck, entry, getJsEntry, jsHandler, jsTaskFactories, linkedByEntry, metrics, onUpdate, outDir, processFiles, rememberProcessCacheKey, runtimeSignature, snapshot, timeTask, transformRuntime, uniAppX, useIncrementalMode } = options;
@@ -2574,16 +2806,26 @@ function processJsBundleEntry(options) {
 		const initialRawSource = originalEntrySource;
 		const linkedSet = useIncrementalMode ? /* @__PURE__ */ new Set() : void 0;
 		if (linkedByEntry && linkedSet) linkedByEntry.set(file, linkedSet);
+		const hashSalt = createJsHashSalt(runtimeSignature, useIncrementalMode ? createLinkedImpactSignature(file, snapshot.linkedImpactsByEntry, snapshot.sourceHashByFile) : void 0);
+		const hashKey = `${file}:js`;
+		const processHash = `${getSnapshotHash(snapshot.sourceHashByFile, file, initialRawSource)}:${hashSalt}`;
+		rememberProcessCacheKey(file, hashKey);
+		if (useIncrementalMode && !shouldTransformJs) {
+			const cachedCode = cache.getHashValue(hashKey)?.hash === processHash ? cache.get(file) : void 0;
+			if (cachedCode !== void 0) {
+				originalSource.code = cachedCode;
+				metrics.js.cacheHits++;
+				debug("js direct replay hit: %s", file);
+				return;
+			}
+		}
 		jsTaskFactories.push(async () => {
 			await timeTask("js", async () => {
-				const hashSalt = createJsHashSalt(runtimeSignature, useIncrementalMode ? createLinkedImpactSignature(file, snapshot.linkedImpactsByEntry, snapshot.sourceHashByFile) : void 0);
-				const hashKey = `${file}:js`;
-				rememberProcessCacheKey(file, hashKey);
 				await processCachedTask({
 					cache,
 					cacheKey: file,
 					hashKey,
-					hash: `${getSnapshotHash(snapshot.sourceHashByFile, file, initialRawSource)}:${hashSalt}`,
+					hash: processHash,
 					applyResult(source) {
 						originalSource.code = source;
 					},
@@ -2741,40 +2983,17 @@ function collectRememberedCssReplayGroups(sources, opts, rootDir, isWebGenerator
 	return groups;
 }
 //#endregion
-//#region src/bundlers/vite/generate-bundle/scoped-generator.ts
-function hasOwnSourceDirectives(rawSource) {
-	return rawSource.includes("@source") || rawSource.includes("@config");
-}
-async function createScopedGeneratorCandidateSignature(rawSource, sourceFile, fallbackSignature, getSourceCandidatesForEntries, options = {}) {
-	if (!getSourceCandidatesForEntries || !hasOwnSourceDirectives(rawSource)) return fallbackSignature;
-	const sourceBase = path.dirname(path.resolve(sourceFile.replace(/[?#].*$/, "")));
-	const resolved = options.majorVersion === 3 ? await resolveTailwindConfigEntriesFromCssCached(rawSource, sourceBase) : await resolveTailwindV4EntriesFromCssCached(rawSource, sourceBase);
-	if (resolved?.entries === void 0) return fallbackSignature;
-	const scopedSignature = createCandidateSignature(getSourceCandidatesForEntries(resolved.entries));
-	return options.includeFallbackSignature === true ? `${scopedSignature}:${fallbackSignature}` : scopedSignature;
-}
-async function createScopedGeneratorRuntime(options) {
-	const { cssHandlerOptions, fallbackRuntime, getSourceCandidatesForEntries, majorVersion, outputFile, rawSource, shouldExcludeSubpackageSourceCandidates, sourceFile, scopedSourceCandidateGetter } = options;
-	if (getSourceCandidatesForEntries && rawSource && sourceFile) {
-		const sourceBase = path.dirname(path.resolve(sourceFile.replace(/[?#].*$/, "")));
-		const resolved = majorVersion === 3 ? await resolveTailwindConfigEntriesFromCssCached(rawSource, sourceBase) : await resolveTailwindV4EntriesFromCssCached(rawSource, sourceBase);
-		if (resolved?.entries !== void 0 && (resolved.entries.length > 0 || hasOwnSourceDirectives(rawSource))) return scopedSourceCandidateGetter?.(resolved.entries) ?? getSourceCandidatesForEntries(resolved.entries);
-	}
-	const scopedCandidates = scopedSourceCandidateGetter?.(void 0);
-	if (scopedCandidates && (scopedCandidates.size > 0 || shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions))) return scopedCandidates;
-	if (!shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions)) return fallbackRuntime;
-	return fallbackRuntime;
-}
-//#endregion
 //#region src/bundlers/vite/generate-bundle/remembered-css-replay.ts
 async function processRememberedCssReplay(options) {
 	const { addWatchFile, activeViteCssCacheFiles, bundleFiles, cache, createScopedGeneratorRuntime, createScopedSourceCandidateGetter, createScopedSourceCandidateSourceGetter, cssTaskFactories, debug, defaultStyleOutputExtension, emitOrReplayCssAsset, generatorRuntime, getCssHandlerOptions, getCssUserHandlerOptions, getRememberedCssSignature, getRememberedCssSources, isNativeAppStyleTarget, isWebGeneratorTarget, lastCssResultByFile, lastCssSourceHashByFile, markCssAssetProcessed, metrics, normalizeViteCssCacheKey, onUpdate, opts, recordCssAssetResult, recordViteProcessedCssAssetResult, refreshRememberedCssSource, rootDir, runtimeState, setRememberedCssSignature, shouldInjectCssIntoMainFromOutput, shouldPreserveAppCssExtension, sourceRoot, styleHandler, timeTask, useIncrementalMode } = options;
 	const rememberedReplayGroups = collectRememberedCssReplayGroups(getRememberedCssSources?.(), opts, rootDir, isWebGeneratorTarget, shouldPreserveAppCssExtension, sourceRoot, defaultStyleOutputExtension, bundleFiles);
 	for (const [outputFile, rememberedGroup] of rememberedReplayGroups) {
+		if (isHTMLRequest(outputFile) || options.opts.htmlMatcher(outputFile)) continue;
 		const refreshedRememberedGroup = await Promise.all(rememberedGroup.map(async (item) => ({
 			key: item.key,
 			remembered: await refreshRememberedCssSource?.(item.remembered) ?? item.remembered
 		})));
+		const rememberedKeys = refreshedRememberedGroup.map((item) => item.key);
 		const rememberedCssSource = mergeRememberedCssSources(refreshedRememberedGroup.map((item) => item.remembered), outputFile);
 		if (!rememberedCssSource) continue;
 		const { rawSource, sourceFile } = rememberedCssSource;
@@ -2787,33 +3006,33 @@ async function processRememberedCssReplay(options) {
 		};
 		const scopedSourceCandidateGetter = createScopedSourceCandidateGetter(outputFile, cssHandlerOptions);
 		const scopedSourceCandidateSourceGetter = createScopedSourceCandidateSourceGetter(outputFile, cssHandlerOptions);
-		const sourceTraceTokenSources = scopedSourceCandidateSourceGetter ? createCssTokenSourceMap(scopedSourceCandidateSourceGetter(void 0), opts) : void 0;
-		const annotateCss = (css) => annotateCssSourceTrace(css, {
-			opts,
-			tokenSources: sourceTraceTokenSources
-		});
 		const scopedGeneratorRuntime = await createScopedGeneratorRuntime(outputFile, cssHandlerOptions, generatorRuntime, rawSource, sourceFile);
 		const cssRuntimeSignature = createCssRuntimeSignature(createCandidateSignature(scopedGeneratorRuntime), await createScopedGeneratorCandidateSignature(rawSource, sourceFile, createCandidateSignature(scopedGeneratorRuntime), scopedSourceCandidateGetter, {
 			includeFallbackSignature: cssHandlerOptions.isMainChunk,
-			majorVersion: runtimeState.twPatcher.majorVersion
+			majorVersion: runtimeState.tailwindRuntime.majorVersion
 		}));
 		const cssRuntimeAffectingHash = cache.computeHash(createRuntimeAffectingSourceSignature(rawSource, "css"));
 		const rememberedCssRuntimeSignature = createRememberedCssRuntimeSignature(cssRuntimeSignature, cssRuntimeAffectingHash);
 		const previousCss = useIncrementalMode && getLastCssSourceHash(lastCssSourceHashByFile, outputFile) === cssRuntimeAffectingHash ? getLastCssResult(lastCssResultByFile, outputFile) : void 0;
-		const rememberedKeys = refreshedRememberedGroup.map((item) => item.key);
 		const allRememberedSignaturesFresh = rememberedKeys.length > 0 && rememberedKeys.every((key) => getRememberedCssSignature?.(key) === rememberedCssRuntimeSignature);
 		if (bundleFiles.includes(outputFile) || bundleFiles.includes(sourceFile) || allRememberedSignaturesFresh) continue;
+		const sourceTraceTokenSources = scopedSourceCandidateSourceGetter ? createCssTokenSourceMap(scopedSourceCandidateSourceGetter(void 0), opts) : void 0;
+		const annotateCss = (css) => annotateCssSourceTrace(css, {
+			opts,
+			tokenSources: sourceTraceTokenSources
+		});
 		const shouldRecordRememberedReplayCss = useIncrementalMode || isNativeAppStyleTarget;
 		const shouldEmitRememberedReplayCssAsset = shouldRecordRememberedReplayCss;
 		if (!shouldRecordRememberedReplayCss) continue;
 		cssTaskFactories.push(() => timeTask("css.replay", async () => {
 			const start = performance.now();
-			const generated = await generateCssByGenerator({
+			const generated = await generateTailwindV4Css({
 				opts,
 				runtimeState,
 				runtime: scopedGeneratorRuntime,
 				rawSource,
 				file: sourceFile,
+				outputFile,
 				cssHandlerOptions,
 				cssUserHandlerOptions: getCssUserHandlerOptions(sourceFile),
 				getSourceCandidatesForEntries: scopedSourceCandidateGetter,
@@ -2905,11 +3124,43 @@ function intersectCandidateSourceMaps(left, right) {
 	for (const [candidate, sources] of left) if (right.has(candidate)) matched.set(candidate, sources);
 	return matched;
 }
+function normalizeSourceFile(file) {
+	return path.resolve(file.replace(/[?#].*$/, ""));
+}
+function resolveSubpackageSourceRootFromFile(file, subpackageRoot) {
+	const normalizedFile = normalizeSourceFile(file).split(path.sep).join("/");
+	const normalizedRoot = subpackageRoot.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+	if (!normalizedRoot) return;
+	const rootSegment = `/${normalizedRoot}/`;
+	const rootIndex = normalizedFile.lastIndexOf(rootSegment);
+	if (rootIndex < 0) return;
+	return normalizedFile.slice(0, rootIndex);
+}
+function collectSubpackageSourceRootsFromCssSources(cssSourceFiles, subpackageRoots) {
+	const sourceRootsByPackageRoot = /* @__PURE__ */ new Map();
+	if (!cssSourceFiles || !subpackageRoots) return sourceRootsByPackageRoot;
+	for (const file of cssSourceFiles) {
+		if (typeof file !== "string" || file.length === 0) continue;
+		for (const root of subpackageRoots) {
+			const sourceRoot = resolveSubpackageSourceRootFromFile(file, root);
+			if (!sourceRoot) continue;
+			const roots = sourceRootsByPackageRoot.get(root) ?? /* @__PURE__ */ new Set();
+			roots.add(sourceRoot);
+			sourceRootsByPackageRoot.set(root, roots);
+		}
+	}
+	return sourceRootsByPackageRoot;
+}
+function flattenSourceRoots(sourceRootsByPackageRoot) {
+	return [...new Set([...sourceRootsByPackageRoot.values()].flatMap((roots) => [...roots]))];
+}
 function createSubpackageSourceCandidateScope(options) {
+	const cssSourceRootsByPackageRoot = collectSubpackageSourceRootsFromCssSources(options.cssSourceFiles, options.subpackageRoots);
 	const subpackageSourceExcludeEntries = options.subpackageRoots ? collectMiniProgramSubpackageSourceEntries(options.snapshot, options.subpackageRoots, [
 		options.rootDir,
 		options.tailwindcssBasedir,
-		options.projectRoot
+		options.projectRoot,
+		...flattenSourceRoots(cssSourceRootsByPackageRoot)
 	]) : [];
 	const isMainPackageStyleOutputFile = (file) => options.subpackageRoots != null && !isSubpackageOutputFile(file, options.subpackageRoots);
 	const resolveSubpackageOutputSourceEntries = (outputFile) => {
@@ -2918,6 +3169,12 @@ function createSubpackageSourceCandidateScope(options) {
 		if (matchedRoots.length !== 1) return;
 		const root = matchedRoots[0];
 		if (!root) return;
+		const configuredSourceRoots = cssSourceRootsByPackageRoot.get(root);
+		if (configuredSourceRoots?.size === 1) return [{
+			base: [...configuredSourceRoots][0],
+			negated: false,
+			pattern: `${root}/**/*`
+		}];
 		return options.sourceRoot ? [{
 			base: options.sourceRoot,
 			negated: false,
@@ -2969,7 +3226,7 @@ function createSubpackageSourceCandidateScope(options) {
 			excludeEntries: [...filterOptions?.excludeEntries ?? [], ...subpackageSourceExcludeEntries]
 		}) ?? /* @__PURE__ */ new Map();
 	};
-	const shouldInjectCssIntoMainFromOutput = (outputFile, _sourceFile, outputCssHandlerOptions) => outputCssHandlerOptions.isMainChunk === true || options.useIncrementalMode && isMainPackageStyleOutputFile(outputFile);
+	const shouldInjectCssIntoMainFromOutput = (outputFile, _sourceFile, outputCssHandlerOptions) => outputCssHandlerOptions.isMainChunk === true && !outputFile.replace(/[?#].*$/, "").includes("/") || options.useIncrementalMode && isMainPackageStyleOutputFile(outputFile);
 	return {
 		createScopedSourceCandidateGetter,
 		createScopedSourceCandidateSourceGetter,
@@ -2992,7 +3249,18 @@ function createBundleTaskTimer(recordTimingDetail) {
 //#endregion
 //#region src/bundlers/vite/uni-app-x-css-options.ts
 function resolveUniAppXNativeCssHandlerOptions(opts) {
-	if (opts.appType !== "uni-app-x" || !isUniAppXEnabled(opts.uniAppX) || !resolveUniUtsPlatform().isApp) return {};
+	const uniUtsPlatform = resolveUniUtsPlatform();
+	if (!shouldUseNativeAppCssBranch(resolveGeneratorRuntimeBranch(normalizeWeappTailwindcssGeneratorOptions(opts.generator, {
+		appType: opts.appType,
+		platform: opts.cssOptions?.platform ?? opts.platform,
+		uniAppX: resolveUniAppXOptions(opts.uniAppX),
+		uniUtsPlatform
+	}), {
+		appType: opts.appType,
+		platform: opts.cssOptions?.platform ?? opts.platform,
+		uniAppX: resolveUniAppXOptions(opts.uniAppX),
+		uniUtsPlatform
+	})) || !isUniAppXEnabled(opts.uniAppX)) return {};
 	return {
 		uniAppX: true,
 		uniAppXCssTarget: "uvue",
@@ -3055,6 +3323,32 @@ function resolveSourceRootFromBundleGraph(config, bundle) {
 }
 //#endregion
 //#region src/bundlers/vite/generate-bundle.ts
+function isRootMiniProgramStyleOutputFile(file) {
+	const normalized = normalizeOutputPathKey(file.replace(/[?#].*$/, ""));
+	return !normalized.includes("/") && /\.(?:wxss|acss|ttss|qss|jxss|tyss)$/i.test(normalized);
+}
+function createRelativeCssImportRequest(targetFile, importedFile) {
+	const normalizedTargetFile = normalizeOutputPathKey(targetFile.replace(/[?#].*$/, ""));
+	const normalizedImportedFile = normalizeOutputPathKey(importedFile.replace(/[?#].*$/, ""));
+	const targetDir = path.posix.dirname(normalizedTargetFile);
+	const baseDir = targetDir === "." ? "" : targetDir;
+	const relative = path.posix.relative(baseDir, normalizedImportedFile);
+	return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function createCssImportShell(targetFile, importedFile) {
+	return `@import "${createRelativeCssImportRequest(targetFile, importedFile)}";\n`;
+}
+function createRootMiniProgramOriginStyleOutputFile(file) {
+	const normalized = normalizeOutputPathKey(file.replace(/[?#].*$/, ""));
+	if (/(?:^|\/)[^/]+-origin\.[^.]+$/i.test(normalized)) return normalized;
+	return normalized.replace(/(\.[^.]+)$/, "-origin$1");
+}
+function shouldKeepRootMiniProgramStyleAsImportShell(appType) {
+	return appType === "uni-app-vite" || appType === "uni-app-x" || appType === "taro";
+}
+function shouldMoveRootMiniProgramStyleToImportShellOrigin(appType) {
+	return appType === "taro";
+}
 function createGenerateBundleHook(context) {
 	const state = createBundleBuildState();
 	const lastCssResultByFile = /* @__PURE__ */ new Map();
@@ -3064,7 +3358,7 @@ function createGenerateBundleHook(context) {
 	const cssHandlerOptions = createCssHandlerOptionsCache({
 		getAppType: () => context.opts.appType,
 		mainCssChunkMatcher: context.opts.mainCssChunkMatcher,
-		getMajorVersion: () => context.runtimeState.twPatcher.majorVersion,
+		getMajorVersion: () => context.runtimeState.tailwindRuntime.majorVersion,
 		getOutputRoot: () => currentOutDir,
 		getExtraOptions: (file) => ({
 			...resolveViteCssHandlerExtraOptions(file),
@@ -3081,15 +3375,27 @@ function createGenerateBundleHook(context) {
 		};
 		const getSfcSource = (sourceFile) => getBundlerSfcSource(sourceFile) ?? getKnownSfcSource?.(sourceFile);
 		const { cache, onEnd, onStart, onUpdate, styleHandler, templateHandler, jsHandler, uniAppX } = opts;
-		const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator);
-		const isWebGeneratorTarget = generatorOptions.target === "web";
 		const resolvedConfig = getResolvedConfig();
 		const uniUtsPlatform = resolveUniUtsPlatform();
+		const generatorBranch = resolveGeneratorRuntimeBranch(normalizeWeappTailwindcssGeneratorOptions(opts.generator, {
+			appType: opts.appType,
+			platform: opts.cssOptions?.platform ?? opts.platform,
+			tailwindcssMajorVersion: runtimeState.tailwindRuntime.majorVersion,
+			uniAppX,
+			uniUtsPlatform
+		}), {
+			appType: opts.appType,
+			platform: opts.cssOptions?.platform ?? opts.platform,
+			tailwindcssMajorVersion: runtimeState.tailwindRuntime.majorVersion,
+			uniAppX,
+			uniUtsPlatform
+		});
+		const isWebGeneratorTarget = generatorBranch.isWeb;
 		const isNativeAppStyleTarget = uniUtsPlatform.isApp;
 		const canInferHarmonyAppStyleTarget = !uniUtsPlatform.normalized || uniUtsPlatform.isApp;
 		const isHarmonyAppStyleTarget = uniUtsPlatform.isAppHarmony || canInferHarmonyAppStyleTarget && (isUniAppXHarmonyBundle(bundle) || isUniAppXHarmonyOutDir(resolvedConfig?.build?.outDir));
 		const shouldPreserveAppCssExtension = isNativeAppStyleTarget || isHarmonyAppStyleTarget;
-		const shouldGenerateWebCssByGenerator = isWebGeneratorTarget && runtimeState.twPatcher.majorVersion === 3;
+		const shouldGenerateWebCssByGenerator = isWebGeneratorTarget;
 		const { getCssHandlerOptions, getCssUserHandlerOptions } = cssHandlerOptions;
 		const rootDir = resolvedConfig?.root ? path.resolve(resolvedConfig.root) : process$1.cwd();
 		const sourceRoot = resolveWeappViteSourceRoot(resolvedConfig, opts.appType) ?? resolveSourceRootFromBundleGraph(resolvedConfig, bundle);
@@ -3122,7 +3428,130 @@ function createGenerateBundleHook(context) {
 		const envFlags = resolveGenerateBundleEnvFlags();
 		const bundleFiles = Object.keys(bundle);
 		const activeViteCssCacheFiles = new Set(bundleFiles.map(normalizeViteCssCacheKey));
-		const configuredTailwindV4CssSourceEntries = collectConfiguredTailwindV4CssSourceEntries(opts, opts.tailwindcssBasedir ?? rootDir);
+		const getConfiguredTailwindV4CssSourceEntries = () => collectConfiguredTailwindV4CssSourceEntries({
+			...opts,
+			tailwindcssRuntimeOptions: {
+				...opts.tailwindcssRuntimeOptions ?? {},
+				tailwindcss: {
+					...resolveTailwindcssOptions(opts.tailwindcssRuntimeOptions) ?? {},
+					...resolveTailwindcssOptions(runtimeState.tailwindRuntime.options) ?? {}
+				}
+			}
+		}, opts.tailwindcssBasedir ?? rootDir);
+		const collectTailwindV4SourceFingerprint = (source) => {
+			const tokens = /* @__PURE__ */ new Set();
+			const add = (prefix, value) => {
+				const normalized = value?.trim();
+				if (normalized) tokens.add(`${prefix}:${normalized}`);
+			};
+			for (const match of source.matchAll(/@config\s+(["'])(.+?)\1\s*;?/g)) {
+				const configRequest = match[2] ?? "";
+				add("config", path.basename(configRequest));
+				add("config-request", configRequest.replace(/\\/g, "/"));
+			}
+			for (const match of source.matchAll(/@source\s+(not\s+)?(["'])(.+?)\2\s*;?/g)) add(match[1] ? "source:not" : "source", match[3]);
+			for (const match of source.matchAll(/@custom-variant\s+([^{\s]+)/g)) add("custom-variant", match[1]);
+			for (const match of source.matchAll(/@(?:theme|utility|variant|layer)\s+([^{;\s]+)/g)) add("directive", match[1]);
+			for (const match of source.matchAll(/--[\w-]+(?=\s*:)/g)) add("theme-token", match[0]);
+			for (const match of source.matchAll(/\.([_a-z][\w-]*)\s*[{,]/gi)) add("selector", match[1]);
+			return tokens;
+		};
+		const scoreConfiguredTailwindV4SourceForRawSource = (rawSource, entrySource) => {
+			if (!rawSource) return 0;
+			const rawTokens = collectTailwindV4SourceFingerprint(rawSource);
+			if (rawTokens.size === 0) return 0;
+			const entryTokens = collectTailwindV4SourceFingerprint(entrySource);
+			let score = 0;
+			for (const token of entryTokens) if (rawTokens.has(token)) score += token.startsWith("config:") ? 100 : 1;
+			return score;
+		};
+		const selectTailwindV4GenerationCssSourceForOutput = (outputFile, entries, rawSource) => {
+			const generationSources = entries.filter((entry) => hasTailwindGenerationSource(entry.source));
+			if (generationSources.length <= 1) return generationSources[0];
+			const selectByRawSourceFingerprint = (candidates) => {
+				const scoredSources = candidates.map((entry) => ({
+					entry,
+					score: scoreConfiguredTailwindV4SourceForRawSource(rawSource, entry.source)
+				})).filter((item) => item.score > 0).sort((a, b) => b.score - a.score);
+				const bestScore = scoredSources[0]?.score;
+				const bestSources = bestScore ? scoredSources.filter((item) => item.score === bestScore) : [];
+				return bestSources.length === 1 ? bestSources[0]?.entry : void 0;
+			};
+			const rawSourceMatched = selectByRawSourceFingerprint(generationSources);
+			if (rawSourceMatched) return rawSourceMatched;
+			const scopedSources = currentSubpackageRoots ? generationSources.filter((entry) => {
+				const outputMatchesSubpackage = isSubpackageOutputFile(outputFile, currentSubpackageRoots);
+				const sourceMatchesSubpackage = isSubpackageOutputFile(entry.file, currentSubpackageRoots);
+				if (!outputMatchesSubpackage) return !sourceMatchesSubpackage;
+				return sourceMatchesSubpackage && [...currentSubpackageRoots].some((root) => isSubpackageOutputFile(outputFile, new Set([root])) && isSubpackageOutputFile(entry.file, new Set([root])));
+			}) : generationSources;
+			const explicitSources = scopedSources.filter((entry) => /@(?:config|source|plugin|custom-variant|theme|utility|variant|apply)\b/.test(entry.source));
+			const candidates = explicitSources.length === 1 ? explicitSources : scopedSources;
+			if (candidates.length === 1) return candidates[0];
+			return selectByRawSourceFingerprint(candidates);
+		};
+		const resolveSubpackageRootForFile = (file) => {
+			if (!file || !currentSubpackageRoots) return;
+			return [...currentSubpackageRoots].find((root) => isSubpackageOutputFile(file, new Set([root])));
+		};
+		const isSameSubpackageScope = (outputFile, sourceFile) => {
+			return resolveSubpackageRootForFile(outputFile) === resolveSubpackageRootForFile(sourceFile);
+		};
+		const normalizeGeneratorUserRawSource = (source, sourceFile, fallbackFile) => normalizeRelativeCssConfigDirectives(source, sourceFile || fallbackFile, outDir, opts);
+		const normalizeSourceCandidatePathKey = (file) => normalizeOutputPathKey(path.resolve(file));
+		const resolveCurrentSourceCandidateSource = (file) => {
+			const cleanedFile = file.replace(/[?#].*$/, "");
+			const normalizedFile = normalizeOutputPathKey(cleanedFile);
+			const absoluteFile = path.isAbsolute(cleanedFile) ? cleanedFile : path.resolve(rootDir, cleanedFile);
+			const relativeFromOutDir = normalizeOutputPathKey(path.relative(outDir, absoluteFile));
+			const sourceCandidates = [
+				sourceRoot ? path.resolve(sourceRoot, file) : void 0,
+				path.resolve(rootDir, file),
+				path.resolve(path.dirname(outDir), file),
+				path.resolve(outDir, file),
+				!path.isAbsolute(relativeFromOutDir) && !relativeFromOutDir.startsWith("../") ? path.resolve(rootDir, relativeFromOutDir) : void 0,
+				!path.isAbsolute(relativeFromOutDir) && !relativeFromOutDir.startsWith("../") ? path.resolve(path.dirname(outDir), relativeFromOutDir) : void 0,
+				file
+			];
+			const explicitSource = sourceCandidates.reduce((source, candidate) => {
+				if (source || !candidate) return source;
+				return getSourceCandidateSource?.(candidate);
+			}, void 0);
+			if (explicitSource) return explicitSource;
+			const normalizedSourceCandidates = sourceCandidates.filter((candidate) => Boolean(candidate)).map((candidate) => ({
+				absolute: path.isAbsolute(candidate),
+				key: normalizeSourceCandidatePathKey(candidate)
+			}));
+			let bestSource;
+			for (const [sourceFile, source] of getSourceCandidateSources?.() ?? []) {
+				const normalizedSourceFile = normalizeSourceCandidatePathKey(sourceFile);
+				let score = 0;
+				for (const candidate of normalizedSourceCandidates) {
+					if (normalizedSourceFile === candidate.key) {
+						score = Math.max(score, candidate.absolute ? 100 : 80);
+						continue;
+					}
+					if (normalizedSourceFile.endsWith(`/${candidate.key}`)) score = Math.max(score, candidate.absolute ? 60 : 40);
+				}
+				if (normalizedSourceFile.endsWith(`/${normalizedFile}`)) score = Math.max(score, 20);
+				if (score > (bestSource?.score ?? 0)) bestSource = {
+					score,
+					source
+				};
+			}
+			return bestSource?.source;
+		};
+		const resolveOutputFileFromMatchedCssSource = (sourceFile) => {
+			if (!sourceFile) return;
+			const outputFile = resolveViteCssPipelineOutputFileFromSourceFile(sourceFile, opts, rootDir, isWebGeneratorTarget, false, sourceRoot, defaultStyleOutputExtension, bundleFiles);
+			return opts.cssMatcher(outputFile) ? outputFile : void 0;
+		};
+		const hasViteProcessedCssResultForSource = (sourceFile) => {
+			const sourceKey = normalizeOutputPathKey(sourceFile);
+			for (const [file] of getViteProcessedCssAssetResults?.() ?? []) if (normalizeOutputPathKey(file) === sourceKey) return true;
+			return false;
+		};
+		const usedConfiguredTailwindV4CssSourceFiles = /* @__PURE__ */ new Set();
 		const buildCommand = resolvedConfig?.command === "build";
 		const hasPreviousBundleState = state.iteration > 0 || state.sourceHashByFile.size > 0;
 		const hasOmittedKnownFiles = hasOmittedKnownBundleFiles(bundleFiles, state.sourceHashByFile.keys());
@@ -3130,10 +3559,13 @@ function createGenerateBundleHook(context) {
 		currentOutDir = outDir;
 		const snapshotStart = performance.now();
 		const snapshot = buildBundleSnapshot(bundle, opts, outDir, state, envFlags.disableDirtyOptimization || !useIncrementalMode, { hasOmittedKnownFiles });
+		const configuredTailwindV4CssSourceEntriesForScope = getConfiguredTailwindV4CssSourceEntries();
+		const configuredTailwindV4CssSourceFileKeysForScope = new Set(configuredTailwindV4CssSourceEntriesForScope.map((entry) => normalizeOutputPathKey(entry.file.replace(/[?#].*$/, ""))));
 		const { createScopedSourceCandidateGetter, createScopedSourceCandidateSourceGetter, shouldExcludeSubpackageSourceCandidates, shouldInjectCssIntoMainFromOutput } = createSubpackageSourceCandidateScope({
+			cssSourceFiles: configuredTailwindV4CssSourceEntriesForScope.map((entry) => entry.file),
 			getSourceCandidateSourcesForEntries,
 			getSourceCandidatesForEntries,
-			projectRoot: opts.tailwindcssPatcherOptions?.projectRoot,
+			projectRoot: opts.tailwindcssRuntimeOptions?.projectRoot,
 			rootDir,
 			snapshot,
 			sourceRoot,
@@ -3142,7 +3574,7 @@ function createGenerateBundleHook(context) {
 			useIncrementalMode
 		});
 		recordTimingDetail("snapshot", snapshotStart);
-		const useBundleRuntimeClassSet = !isWebGeneratorTarget && (useIncrementalMode || runtimeState.twPatcher.majorVersion === 4);
+		const useBundleRuntimeClassSet = !isWebGeneratorTarget;
 		const forceRuntimeRefreshBySource = useIncrementalMode && hasRuntimeAffectingSourceChanges(snapshot.runtimeAffectingChangedByType);
 		const processFiles = snapshot.processFiles;
 		logBundleProcessPlan({
@@ -3159,7 +3591,7 @@ function createGenerateBundleHook(context) {
 			cssHandlerOptions,
 			fallbackRuntime: runtime,
 			getSourceCandidatesForEntries,
-			majorVersion: runtimeState.twPatcher.majorVersion,
+			majorVersion: runtimeState.tailwindRuntime.majorVersion,
 			outputFile,
 			rawSource,
 			shouldExcludeSubpackageSourceCandidates,
@@ -3169,28 +3601,17 @@ function createGenerateBundleHook(context) {
 		const jsEntries = snapshot.jsEntries;
 		const getJsEntry = createJsEntryResolver(jsEntries);
 		const moduleGraphOptions = createBundleModuleGraphOptions(outDir, jsEntries);
-		const hasCssAssetEntry = snapshot.entries.some((entry) => entry.type === "css" && entry.output.type === "asset");
 		const hasRuntimeAffectingChanges = hasRuntimeAffectingSourceChanges(snapshot.runtimeAffectingChangedByType);
-		const useV3OxideSourceRuntime = runtimeState.twPatcher.majorVersion === 3 && sourceCandidates.size > 0 && hasCssAssetEntry && !envFlags.forceRuntimeRefreshByEnv && !envFlags.disableV3OxideSourceRuntime;
 		const runtimeStart = performance.now();
-		const transformBaseRuntime = useV3OxideSourceRuntime ? await ensureBundleRuntimeClassSet(snapshot, envFlags.forceRuntimeRefreshByEnv, { transformOnly: true }) : void 0;
-		const forceV4RuntimeRefreshBySource = runtimeState.twPatcher.majorVersion === 4 && forceRuntimeRefreshBySource;
-		const runtime = isWebGeneratorTarget && !shouldGenerateWebCssByGenerator ? /* @__PURE__ */ new Set() : useV3OxideSourceRuntime ? await ensureBundleRuntimeClassSet(snapshot, envFlags.forceRuntimeRefreshByEnv, {
-			allowBaselineOnlyInitialSync: true,
-			baseClassSet: sourceCandidates
-		}) : useBundleRuntimeClassSet ? await ensureBundleRuntimeClassSet(snapshot, envFlags.forceRuntimeRefreshByEnv || forceV4RuntimeRefreshBySource, { allowBaselineOnlyInitialSync: buildCommand }) : await context.ensureRuntimeClassSet(envFlags.forceRuntimeRefreshByEnv);
-		if (useV3OxideSourceRuntime) debug("[tailwindcss:v3] use oxide source candidates as runtime input, candidates=%d", sourceCandidates.size);
-		const shouldFilterTailwindV4MiniProgramCandidates = runtimeState.twPatcher.majorVersion === 4 && generatorOptions.target === "weapp";
+		const forceV4RuntimeRefreshBySource = forceRuntimeRefreshBySource;
+		const runtime = isWebGeneratorTarget && !shouldGenerateWebCssByGenerator ? /* @__PURE__ */ new Set() : useBundleRuntimeClassSet ? await ensureBundleRuntimeClassSet(snapshot, envFlags.forceRuntimeRefreshByEnv || forceV4RuntimeRefreshBySource, { allowBaselineOnlyInitialSync: buildCommand }) : await context.ensureRuntimeClassSet(envFlags.forceRuntimeRefreshByEnv);
+		const shouldFilterTailwindV4MiniProgramCandidates = shouldUseMiniProgramCssBranch(generatorBranch);
 		const collectedGeneratorCandidates = new Set([...runtime, ...sourceCandidates]);
 		const filteredGeneratorCandidates = shouldFilterTailwindV4MiniProgramCandidates ? filterUnsupportedMiniProgramTailwindV4Candidates(collectedGeneratorCandidates) : collectedGeneratorCandidates;
-		let transformRuntime = transformBaseRuntime ?? runtime;
-		let generatorRuntime = collectLegacyContainerCompatCandidates(sourceCandidates, runtimeState.twPatcher.majorVersion === 3 && hasRuntimeAffectingChanges && transformBaseRuntime ? new Set([...filteredGeneratorCandidates, ...transformBaseRuntime]) : filteredGeneratorCandidates);
-		if (runtimeState.twPatcher.majorVersion === 3 && generatorRuntime.size === 0) {
-			generatorRuntime = await context.ensureRuntimeClassSet(envFlags.forceRuntimeRefreshByEnv);
-			transformRuntime = generatorRuntime;
-		}
+		const transformRuntime = runtime;
+		const generatorRuntime = filteredGeneratorCandidates;
 		const cssEntries = snapshot.entries.filter((entry) => entry.type === "css" && entry.output.type === "asset");
-		if (runtimeState.twPatcher.majorVersion === 4 && sourceCandidates.size > 0 && jsEntries.size > 0) {
+		if (sourceCandidates.size > 0 && jsEntries.size > 0) {
 			const mainCssEntry = cssEntries.find((entry) => getCssHandlerOptions(entry.file).isMainChunk) ?? cssEntries[0];
 			if (mainCssEntry) {
 				const validatedSourceRuntime = await validateCandidatesByGenerator({
@@ -3205,27 +3626,7 @@ function createGenerateBundleHook(context) {
 					debug,
 					skipGenerateFallback: true
 				});
-				if (validatedSourceRuntime.size > 0) transformRuntime = new Set([...transformRuntime, ...validatedSourceRuntime]);
-			}
-		}
-		if (runtimeState.twPatcher.majorVersion === 3 && useV3OxideSourceRuntime && generatorRuntime.size > 0 && (state.iteration === 0 || !hasRuntimeAffectingChanges) && cssEntries.length <= 1) {
-			const mainCssEntry = cssEntries.find((entry) => getCssHandlerOptions(entry.file).isMainChunk) ?? cssEntries[0];
-			if (mainCssEntry) {
-				const validatedRuntime = await validateCandidatesByGenerator({
-					opts,
-					runtimeState,
-					candidates: generatorRuntime,
-					rawSource: mainCssEntry.source,
-					file: mainCssEntry.file,
-					cssHandlerOptions: getCssHandlerOptions(mainCssEntry.file),
-					cssUserHandlerOptions: getCssUserHandlerOptions(mainCssEntry.file),
-					styleHandler,
-					debug
-				});
-				if (validatedRuntime.size > 0) {
-					generatorRuntime = collectLegacyContainerCompatCandidates(sourceCandidates, validatedRuntime);
-					transformRuntime = generatorRuntime;
-				}
+				if (validatedSourceRuntime.size > 0) for (const candidate of validatedSourceRuntime) transformRuntime.add(candidate);
 			}
 		}
 		const generatorCandidateSignature = createCandidateSignature(generatorRuntime);
@@ -3239,7 +3640,7 @@ function createGenerateBundleHook(context) {
 				continue;
 			}
 			const outputFile = resolveViteCssPipelineOutputFile(file, opts, rootDir, isWebGeneratorTarget, shouldPreserveAppCssExtension, sourceRoot, defaultStyleOutputExtension, bundleFiles);
-			const inferredSourceStyle = resolveSourceStyleSourceFromOutputFile(outputFile, snapshot, outDir, sourceRoot, getSourceCandidateSource, jsImportedCssFiles.has(file) ? getSourceCandidateSources : void 0, configuredTailwindV4CssSourceEntries.map((entry) => [entry.file, entry.source]), debug);
+			const inferredSourceStyle = resolveSourceStyleSourceFromOutputFile(outputFile, snapshot, outDir, sourceRoot, getSourceCandidateSource, jsImportedCssFiles.has(file) ? getSourceCandidateSources : void 0, getConfiguredTailwindV4CssSourceEntries().map((entry) => [entry.file, entry.source]), debug);
 			const rawSource = inferredSourceStyle?.rawSource ?? getSourceCandidateSource?.(path.resolve(outDir, file)) ?? getSourceCandidateSource?.(file);
 			if (rawSource === void 0 || !hasTailwindGenerationSource(rawSource)) continue;
 			rememberCssSource?.({
@@ -3254,12 +3655,12 @@ function createGenerateBundleHook(context) {
 			...generatorRuntime,
 			...transformRuntime
 		]);
-		const defaultTemplateHandlerOptions = { runtimeSet: transformRuntime };
 		metrics.runtimeSet = measureElapsed(runtimeStart);
 		timingDetails["runtime"] = metrics.runtimeSet;
 		if (forceRuntimeRefreshBySource) debug("runtimeSet forced refresh due to source changes: html=%d js=%d", snapshot.runtimeAffectingChangedByType.html.size, snapshot.runtimeAffectingChangedByType.js.size);
 		debug("get runtimeSet, class count: %d, transform class count: %d", runtime.size, transformRuntime.size);
-		const runtimeSignature = getRuntimeClassSetSignature(runtimeState.twPatcher) ?? "runtime:missing";
+		const runtimeSignature = getRuntimeClassSetSignature(runtimeState.tailwindRuntime) ?? "runtime:missing";
+		const transformRuntimeSignature = createCandidateSignature(transformRuntime);
 		const shouldProcessTailwindGeneration = !useIncrementalMode || hasRuntimeAffectingChanges || generatorCandidatesChanged || snapshot.processFiles.css.size > 0;
 		const { applyLinkedUpdates, pendingLinkedUpdates } = createLinkedUpdateHelpers({
 			jsEntries,
@@ -3267,7 +3668,7 @@ function createGenerateBundleHook(context) {
 			debug
 		});
 		const createHandlerOptions = createJsHandlerOptionsFactory({
-			getMajorVersion: () => runtimeState.twPatcher.majorVersion,
+			getMajorVersion: () => runtimeState.tailwindRuntime.majorVersion,
 			moduleGraph: moduleGraphOptions
 		});
 		const linkedByEntry = useIncrementalMode ? /* @__PURE__ */ new Map() : void 0;
@@ -3290,15 +3691,19 @@ function createGenerateBundleHook(context) {
 					continue;
 				}
 				if (!processFiles.html.has(file)) continue;
-				const rawSource = originalEntrySource;
-				const cacheKey = file;
-				const hashKey = `${file}:html:${runtimeSignature}`;
+				const rawSource = resolveCurrentSourceCandidateSource(file) ?? originalEntrySource;
+				const currentRawDynamicCandidates = collectUnescapedDynamicCandidates(rawSource);
+				const templateRuntime = currentRawDynamicCandidates.length > 0 ? new Set([...transformRuntime, ...currentRawDynamicCandidates]) : transformRuntime;
+				const templateRuntimeSignature = templateRuntime === transformRuntime ? transformRuntimeSignature : createCandidateSignature(templateRuntime);
+				const htmlProcessHash = `${cache.computeHash(rawSource)}:${cache.computeHash(createRuntimeAffectingSourceSignature(rawSource, "html"))}:${templateRuntimeSignature}`;
+				const cacheKey = `${file}:html:${htmlProcessHash}`;
+				const hashKey = cacheKey;
 				rememberProcessCacheKey(cacheKey, hashKey);
 				tasks.push(timeTask("html", () => processCachedTask({
 					cache,
 					cacheKey,
 					hashKey,
-					hash: getSnapshotHash(snapshot.sourceHashByFile, file, rawSource),
+					hash: htmlProcessHash,
 					applyResult(source) {
 						originalSource.source = source;
 					},
@@ -3308,7 +3713,7 @@ function createGenerateBundleHook(context) {
 					},
 					async transform() {
 						const start = performance.now();
-						let transformed = await templateHandler(rawSource, defaultTemplateHandlerOptions);
+						let transformed = await templateHandler(rawSource, { runtimeSet: templateRuntime });
 						let unresolvedDynamicCandidates = collectUnescapedDynamicCandidates(transformed);
 						let retryRuntimeSet;
 						if (unresolvedDynamicCandidates.length > 0) {
@@ -3336,7 +3741,14 @@ function createGenerateBundleHook(context) {
 				metrics.css.total++;
 				const assetSourceFile = resolveAssetSourceFile(originalSource, file);
 				const rawSource = normalizeRelativeCssConfigDirectives(originalEntrySource, assetSourceFile, outDir, opts);
-				const outputFile = resolveViteCssOutputFile(file, opts, isWebGeneratorTarget, shouldPreserveAppCssExtension, defaultStyleOutputExtension, bundleFiles);
+				let outputFile = resolveViteCssOutputFile(file, opts, isWebGeneratorTarget, shouldPreserveAppCssExtension, defaultStyleOutputExtension, bundleFiles);
+				if (outputFile !== file && (originalSource.originalFileNames?.length ?? 0) > 0 && opts.cssMatcher(file)) outputFile = file;
+				if (outputFile === file && isRootMiniProgramStyleOutputFile(file) && shouldMoveRootMiniProgramStyleToImportShellOrigin(opts.appType)) outputFile = createRootMiniProgramOriginStyleOutputFile(file);
+				const resolveMatchedOutputFileForCurrentAsset = (sourceFile) => {
+					if (!sourceFile) return;
+					if (normalizeOutputPathKey(assetSourceFile.replace(/[?#].*$/, "")) === normalizeOutputPathKey(sourceFile.replace(/[?#].*$/, "")) || originalSource.originalFileNames?.some((originalFile) => normalizeOutputPathKey(originalFile.replace(/[?#].*$/, "")) === normalizeOutputPathKey(sourceFile.replace(/[?#].*$/, "")))) return file;
+					return resolveOutputFileFromMatchedCssSource(sourceFile);
+				};
 				activeViteCssCacheFiles.add(normalizeViteCssCacheKey(outputFile));
 				if (outputFile !== file && !canProcessViteSourceStyleAsCss(rawSource, file)) {
 					delete bundle[file];
@@ -3345,9 +3757,19 @@ function createGenerateBundleHook(context) {
 				}
 				const applyCssResult = (source) => {
 					if (outputFile !== file) {
-						emitOrReplayCssAsset(outputFile, source);
+						const importShellSource = isRootMiniProgramStyleOutputFile(file) && isRootMiniProgramStyleOutputFile(outputFile) && shouldKeepRootMiniProgramStyleAsImportShell(opts.appType) ? createCssImportShell(file, outputFile) : void 0;
+						if (bundle[file] === originalSource && originalSource.originalFileNames?.includes(assetSourceFile)) {
+							const existingOutput = bundle[outputFile];
+							if (existingOutput?.type === "asset") existingOutput.source = source;
+							else emitOrReplayCssAsset(outputFile, source);
+							originalSource.source = importShellSource ?? source;
+							return;
+						}
+						const existingOutput = bundle[outputFile];
+						if (existingOutput?.type === "asset") existingOutput.source = source;
+						else emitOrReplayCssAsset(outputFile, source);
 						if (!viteProcessedCssAsset && SOURCE_STYLE_OUTPUT_EXT_RE.test(file)) delete bundle[file];
-						else originalSource.source = "";
+						else originalSource.source = importShellSource ?? "";
 						return;
 					}
 					originalSource.source = source;
@@ -3365,18 +3787,59 @@ function createGenerateBundleHook(context) {
 				const alreadyProcessedCssAsset = viteProcessedCssAsset || cssAssetProcessed;
 				let rememberedCssSources = findRememberedCssSources(getRememberedCssSources?.(), outputFile, file, originalSource, outDir, opts.tailwindcssBasedir);
 				if (rememberedCssSources.length > 0) rememberedCssSources = await Promise.all(rememberedCssSources.map(async (remembered) => await refreshRememberedCssSource?.(remembered) ?? remembered));
-				const hasUsableRememberedTailwindSource = rememberedCssSources.some((remembered) => hasTailwindGenerationSource(remembered.rawSource) && normalizeOutputPathKey(remembered.sourceFile.replace(/[?#].*$/, "")) !== normalizeOutputPathKey(file));
+				let hasUsableRememberedTailwindSource = rememberedCssSources.some((remembered) => hasTailwindGenerationSource(remembered.rawSource) && normalizeOutputPathKey(remembered.sourceFile.replace(/[?#].*$/, "")) !== normalizeOutputPathKey(file));
 				const inferredSfcStyleSource = await resolveSfcStyleSourceFromOutputFile(outputFile, snapshot, outDir, opts.tailwindcssBasedir, opts.cssMatcher, getSfcSource, debug);
 				if (inferredSfcStyleSource) {
 					const inferredSourceFile = normalizeSfcSourceFileForCompare(inferredSfcStyleSource.sourceFile);
 					const rememberedSourcesBelongToInferredSfc = rememberedCssSources.length > 0 && rememberedCssSources.every((remembered) => normalizeSfcSourceFileForCompare(remembered.sourceFile) === inferredSourceFile);
 					if (!hasUsableRememberedTailwindSource || rememberedSourcesBelongToInferredSfc) rememberedCssSources = [inferredSfcStyleSource];
 				}
-				if (!rememberedCssSources.some((remembered) => hasTailwindGenerationSource(remembered.rawSource))) {
-					const inferredSourceStyle = resolveSourceStyleSourceFromOutputFile(outputFile, snapshot, outDir, sourceRoot, getSourceCandidateSource, getSourceCandidateSources, configuredTailwindV4CssSourceEntries.map((entry) => [entry.file, entry.source]), debug);
-					if (inferredSourceStyle) rememberedCssSources = [inferredSourceStyle];
+				let outputCssHandlerOptions = getCssHandlerOptions(outputFile);
+				if (currentSubpackageRoots && rememberedCssSources.length > 0 && rememberedCssSources.some((remembered) => configuredTailwindV4CssSourceFileKeysForScope.has(normalizeOutputPathKey(remembered.sourceFile.replace(/[?#].*$/, ""))) && !isSameSubpackageScope(outputFile, remembered.sourceFile))) {
+					rememberedCssSources = [];
+					hasUsableRememberedTailwindSource = false;
+				}
+				if (!hasUsableRememberedTailwindSource) {
+					const configuredTailwindV4CssSourceEntries = getConfiguredTailwindV4CssSourceEntries();
+					const inferredOriginalSourceStyle = resolveSourceStyleSourceFromOutputFile(outputFile, snapshot, outDir, sourceRoot, getSourceCandidateSource, getSourceCandidateSources, configuredTailwindV4CssSourceEntries.map((entry) => [entry.file, entry.source]), debug) ?? (outputFile === file ? void 0 : resolveSourceStyleSourceFromOutputFile(file, snapshot, outDir, sourceRoot, getSourceCandidateSource, getSourceCandidateSources, configuredTailwindV4CssSourceEntries.map((entry) => [entry.file, entry.source]), debug));
+					if (inferredOriginalSourceStyle) {
+						outputFile = resolveMatchedOutputFileForCurrentAsset(inferredOriginalSourceStyle.sourceFile) ?? outputFile;
+						activeViteCssCacheFiles.add(normalizeViteCssCacheKey(outputFile));
+						outputCssHandlerOptions = getCssHandlerOptions(outputFile);
+						rememberedCssSources = [{
+							...inferredOriginalSourceStyle,
+							outputFile
+						}];
+					} else if (hasTailwindGenerationSource(rawSource) && (originalSource.originalFileNames?.length ?? 0) === 0) {
+						const availableConfiguredTailwindV4CssSourceEntries = configuredTailwindV4CssSourceEntries.filter((entry) => !usedConfiguredTailwindV4CssSourceFiles.has(normalizeOutputPathKey(entry.file)));
+						const configuredGenerationSource = selectTailwindV4GenerationCssSourceForOutput(outputFile, availableConfiguredTailwindV4CssSourceEntries, rawSource);
+						if (configuredGenerationSource && !hasViteProcessedCssResultForSource(configuredGenerationSource.file)) {
+							outputFile = resolveMatchedOutputFileForCurrentAsset(configuredGenerationSource.file) ?? outputFile;
+							activeViteCssCacheFiles.add(normalizeViteCssCacheKey(outputFile));
+							outputCssHandlerOptions = getCssHandlerOptions(outputFile);
+							usedConfiguredTailwindV4CssSourceFiles.add(normalizeOutputPathKey(configuredGenerationSource.file));
+							rememberedCssSources = [{
+								outputFile,
+								rawSource: configuredGenerationSource.source,
+								sourceFile: configuredGenerationSource.file
+							}];
+							debug("source style source inferred from scoped configured tailwind v4 css source: %s -> %s", outputFile, configuredGenerationSource.file);
+						}
+					}
+				}
+				let rememberedCssSource = mergeRememberedCssSources(rememberedCssSources, outputFile);
+				if (rememberedCssSource && viteProcessedCssAsset && outputCssHandlerOptions.isMainChunk !== true && configuredTailwindV4CssSourceFileKeysForScope.has(normalizeOutputPathKey(rememberedCssSource.sourceFile.replace(/[?#].*$/, "")))) {
+					const matchedOutputFile = resolveMatchedOutputFileForCurrentAsset(rememberedCssSource.sourceFile);
+					if (matchedOutputFile && normalizeOutputPathKey(matchedOutputFile) !== normalizeOutputPathKey(outputFile)) {
+						outputFile = matchedOutputFile;
+						activeViteCssCacheFiles.add(normalizeViteCssCacheKey(outputFile));
+						outputCssHandlerOptions = getCssHandlerOptions(outputFile);
+						rememberedCssSource = {
+							...rememberedCssSource,
+							outputFile
+						};
+					}
 				}
-				const rememberedCssSource = mergeRememberedCssSources(rememberedCssSources, outputFile);
 				const shouldKeepImportedCssShell = isCssImportOnlyBundleAsset(bundle, file, rawSource);
 				const useRememberedCssSource = !shouldKeepImportedCssShell && rememberedCssSource != null && (normalizeOutputPathKey(rememberedCssSource.sourceFile) !== normalizeOutputPathKey(file) || !hasTailwindGenerationSource(rawSource) && hasTailwindGenerationSource(rememberedCssSource.rawSource));
 				const vitePipelineCssAsset = viteProcessedCssAsset || useRememberedCssSource;
@@ -3394,28 +3857,37 @@ function createGenerateBundleHook(context) {
 				}
 				const hasRememberedApplyDirective = rememberedCssSource != null && hasTailwindApplyDirective(rememberedCssSource.rawSource);
 				const hasRememberedTailwindGenerationSource = rememberedCssSource != null && hasTailwindGenerationSource(rememberedCssSource.rawSource);
+				const usesConfiguredTailwindV4FallbackSource = rememberedCssSource != null && normalizeOutputPathKey(rememberedCssSource.outputFile) === normalizeOutputPathKey(outputFile) && normalizeOutputPathKey(rememberedCssSource.sourceFile.replace(/[?#].*$/, "")) !== normalizeOutputPathKey(file);
 				const hasSameOutputRememberedTailwindGenerationSource = hasRememberedTailwindGenerationSource && rememberedCssSource != null && normalizeOutputPathKey(rememberedCssSource.outputFile) === normalizeOutputPathKey(outputFile);
-				const hasStaleViteProcessedCssSource = vitePipelineCssAsset && hasDifferentRememberedCssSource && (hasCurrentTailwindGenerationDirective || hasRememberedApplyDirective || runtimeState.twPatcher.majorVersion === 4 && hasRememberedTailwindGenerationSource);
+				const hasStaleViteProcessedCssSource = vitePipelineCssAsset && hasDifferentRememberedCssSource && (hasCurrentTailwindGenerationDirective || hasRememberedApplyDirective || hasRememberedTailwindGenerationSource);
 				const generatorSourceFile = vitePipelineCssAsset ? rememberedCssSource?.sourceFile ?? assetSourceFile : assetSourceFile;
-				const outputCssHandlerOptions = getCssHandlerOptions(outputFile);
+				if (vitePipelineCssAsset && outputCssHandlerOptions.isMainChunk !== true && configuredTailwindV4CssSourceFileKeysForScope.has(normalizeOutputPathKey(generatorSourceFile.replace(/[?#].*$/, "")))) usedConfiguredTailwindV4CssSourceFiles.add(normalizeOutputPathKey(generatorSourceFile));
 				const cssHandlerOptions = vitePipelineCssAsset ? {
 					...getCssHandlerOptions(generatorSourceFile),
 					isMainChunk: outputCssHandlerOptions.isMainChunk
 				} : getCssHandlerOptions(file);
-				const scopedSourceCandidateGetter = createScopedSourceCandidateGetter(outputFile, cssHandlerOptions);
-				const scopedSourceCandidateSourceGetter = createScopedSourceCandidateSourceGetter(outputFile, cssHandlerOptions);
+				const generatorCssHandlerOptions = {
+					...cssHandlerOptions,
+					sourceOptions: {
+						...cssHandlerOptions.sourceOptions ?? {},
+						sourceFile: generatorSourceFile,
+						cssEntries: opts.cssEntries
+					}
+				};
+				const scopedSourceCandidateGetter = createScopedSourceCandidateGetter(outputFile, generatorCssHandlerOptions);
+				const scopedSourceCandidateSourceGetter = createScopedSourceCandidateSourceGetter(outputFile, generatorCssHandlerOptions);
 				const sourceTraceTokenSources = scopedSourceCandidateSourceGetter ? createCssTokenSourceMap(scopedSourceCandidateSourceGetter(void 0), opts) : void 0;
 				const sourceTraceSignature = createCssSourceTraceCacheSignature(sourceTraceTokenSources, opts);
-				const scopedGeneratorRuntime = await createScopedGeneratorRuntime$1(outputFile, cssHandlerOptions, generatorRuntime, generatorRawSource, generatorSourceFile);
+				const scopedGeneratorRuntime = await createScopedGeneratorRuntime$1(outputFile, generatorCssHandlerOptions, generatorRuntime, generatorRawSource, generatorSourceFile);
 				const annotateCss = (css) => annotateCssSourceTrace(css, {
 					opts,
 					tokenSources: sourceTraceTokenSources
 				});
-				const shouldRegenerateMainPackageCssWithScopedCandidates = vitePipelineCssAsset && shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions);
+				const shouldRegenerateMainPackageCssWithScopedCandidates = vitePipelineCssAsset && shouldExcludeSubpackageSourceCandidates(outputFile, generatorCssHandlerOptions);
 				const generatorCssUserHandlerOptions = getCssUserHandlerOptions(generatorSourceFile);
 				const cssRuntimeAffectingSignature = vitePipelineCssAsset ? createRuntimeAffectingSourceSignature(generatorRawSource, "css") : snapshot.runtimeAffectingSignatureByFile.get(file) ?? createRuntimeAffectingSourceSignature(generatorRawSource, "css");
 				const cssRuntimeAffectingHash = vitePipelineCssAsset ? cache.computeHash(cssRuntimeAffectingSignature) : snapshot.runtimeAffectingHashByFile.get(file) ?? cache.computeHash(cssRuntimeAffectingSignature);
-				const cssShareScope = createCssTransformShareScopeKey(opts, generatorSourceFile, generatorRawSource);
+				const cssShareScope = createCssTransformShareScopeKey(opts, outputFile, generatorRawSource);
 				const shouldRegenerateCollectedViteCss = viteProcessedCssAsset && useIncrementalMode && state.generatorCandidateSignature !== void 0 && generatorCandidatesChanged && (hasTailwindGenerationSource(generatorRawSource) || hasBundlerGeneratedCssMarker(rawSource) || rememberedCssSource != null && hasTailwindGenerationSource(rememberedCssSource.rawSource));
 				const shouldRefreshViteProcessedCssByCandidates = viteProcessedCssAsset && useIncrementalMode && state.generatorCandidateSignature !== void 0 && generatorCandidatesChanged;
 				const shouldInjectVitePipelineCssIntoMain = vitePipelineCssAsset && outputCssHandlerOptions.isMainChunk !== true && shouldInjectCssIntoMainFromOutput(outputFile, generatorSourceFile, outputCssHandlerOptions);
@@ -3436,14 +3908,14 @@ function createGenerateBundleHook(context) {
 				}
 				const trackedGeneratorCandidateSignature = shouldTrackGeneratorRuntime ? createCandidateSignature(scopedGeneratorRuntime) : "generator:stable";
 				const scopedGeneratorCandidateSignature = shouldTrackGeneratorRuntime ? await createScopedGeneratorCandidateSignature(generatorRawSource, generatorSourceFile, trackedGeneratorCandidateSignature, scopedSourceCandidateGetter, {
-					includeFallbackSignature: cssHandlerOptions.isMainChunk,
-					majorVersion: runtimeState.twPatcher.majorVersion
+					includeFallbackSignature: generatorCssHandlerOptions.isMainChunk,
+					majorVersion: runtimeState.tailwindRuntime.majorVersion
 				}) : trackedGeneratorCandidateSignature;
 				const cssRuntimeSignature = createCssRuntimeSignature(runtimeSignature, scopedGeneratorCandidateSignature);
 				const rememberedCssRuntimeSignature = createRememberedCssRuntimeSignature(cssRuntimeSignature, cssRuntimeAffectingHash);
-				const cssSharedCacheKey = `${cssShareScope}:${cssRuntimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}:${cssHandlerOptions.isMainChunk ? "1" : "0"}:${cssRuntimeAffectingSignature}:${sourceTraceSignature}`;
+				const cssSharedCacheKey = `${cssShareScope}:${cssRuntimeSignature}:${runtimeState.tailwindRuntime.majorVersion ?? "unknown"}:${cssHandlerOptions.isMainChunk ? "1" : "0"}:${cssRuntimeAffectingSignature}:${scopedGeneratorCandidateSignature}:${sourceTraceSignature}`;
 				const cssCacheKey = file;
-				const cssHashKey = `${file}:css:${cssRuntimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}`;
+				const cssHashKey = `${file}:css:${cssRuntimeSignature}:${runtimeState.tailwindRuntime.majorVersion ?? "unknown"}`;
 				const cssLinkedImpactSignature = runtimeLinkedCssFiles.has(file) || runtimeLinkedCssFiles.has(outputFile) ? [...[...snapshot.runtimeAffectingChangedByType.html].sort().map((changedFile) => snapshot.runtimeAffectingSignatureByFile.get(changedFile) ?? ""), ...[...snapshot.runtimeAffectingChangedByType.js].sort().map((changedFile) => snapshot.runtimeAffectingSignatureByFile.get(changedFile) ?? "")].join(":") : "";
 				if (!shouldTrackGeneratorRuntime && !runtimeLinkedCssFiles.has(file) && !runtimeLinkedCssFiles.has(outputFile)) {
 					const lastCss = getLastCssResult(lastCssResultByFile, outputFile, file);
@@ -3489,19 +3961,24 @@ function createGenerateBundleHook(context) {
 						const runTransform = async () => {
 							const start = performance.now();
 							await runtimeState.readyPromise;
-							const generated = await generateCssByGenerator({
+							const previousCss = !vitePipelineCssAsset && useIncrementalMode && !hasRuntimeAffectingChanges && !snapshot.changedByType.css.has(file) ? getLastCssResult(lastCssResultByFile, outputFile, file) : void 0;
+							const generated = hasTailwindGenerationSource(generatorRawSource) || hasBundlerGeneratedCssMarker(rawSource) ? await generateTailwindV4Css({
 								opts,
 								runtimeState,
 								runtime: scopedGeneratorRuntime,
 								rawSource: generatorRawSource,
 								file: generatorSourceFile,
-								cssHandlerOptions,
+								outputFile,
+								cssHandlerOptions: generatorCssHandlerOptions,
 								cssUserHandlerOptions: generatorCssUserHandlerOptions,
 								getSourceCandidatesForEntries: scopedSourceCandidateGetter,
+								sourceCandidates: scopedGeneratorRuntime,
 								styleHandler,
 								debug,
-								previousCss: !vitePipelineCssAsset && useIncrementalMode && !hasRuntimeAffectingChanges && !snapshot.changedByType.css.has(file) ? getLastCssResult(lastCssResultByFile, outputFile, file) : void 0
-							});
+								previousCss,
+								...vitePipelineCssAsset && !hasBundlerGeneratedCssMarker(rawSource) && normalizeCssSourceForCompare(rawSource) !== normalizeCssSourceForCompare(generatorRawSource) ? { userRawSource: normalizeGeneratorUserRawSource(rawSource, generatorSourceFile, assetSourceFile) } : {},
+								...usesConfiguredTailwindV4FallbackSource ? { restoreLocalCssImports: false } : {}
+							}) : void 0;
 							if (generated) {
 								const tracedCss = annotateCss(generated.css);
 								registerGeneratorDependencies$1({ addWatchFile }, generated.dependencies);
@@ -3518,7 +3995,7 @@ function createGenerateBundleHook(context) {
 								});
 								metrics.css.elapsed += measureElapsed(start);
 								metrics.css.transformed++;
-								debug("css handle via tailwind v%s engine(%s): %s", runtimeState.twPatcher.majorVersion, generated.target, outputFile);
+								debug("css handle via tailwind v%s engine(%s): %s", runtimeState.tailwindRuntime.majorVersion, generated.target, outputFile);
 								return tracedCss;
 							}
 							if (isWebGeneratorTarget) {
@@ -3695,12 +4172,16 @@ function createCssHandlerOptions(opts, majorVersion, file) {
 		...majorVersion === void 0 ? {} : { majorVersion }
 	};
 }
-function shouldGenerateCssByGenerator(opts, file, rawSource, processed) {
-	const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator);
+function shouldGenerateCssByGenerator(opts, majorVersion, file, rawSource, processed) {
+	const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator, {
+		appType: opts.appType,
+		platform: opts.cssOptions?.platform ?? opts.platform,
+		tailwindcssMajorVersion: majorVersion,
+		uniAppX: opts.uniAppX
+	});
 	if (hasLocalCssImport(rawSource)) return false;
 	if (hasTailwindGeneratedCssMarkers(rawSource)) return true;
 	if (hasTailwindRootDirectives(rawSource, { importFallback: generatorOptions.importFallback })) return true;
-	if (opts.twPatcher.majorVersion === 3) return false;
 	return processed && hasTailwindApplyDirective(rawSource) && shouldFinalizeProcessedCssAsset(opts, file);
 }
 function shouldFinalizeProcessedCssAsset(opts, file) {
@@ -3718,9 +4199,21 @@ function createViteCssFinalizerOutputPlugin(context) {
 			async handler(_options, bundle) {
 				const { opts, runtimeState, ensureRuntimeClassSet, isCssAssetProcessed, markCssAssetProcessed, debug, getResolvedConfig, recordCssAssetResult, recordViteProcessedCssAssetResult, getViteProcessedCssAssetResults, getRecordedGeneratorCandidates, getSourceCandidates, getSourceCandidatesForEntries, getSourceCandidateSourcesForEntries, waitForSourceCandidateSyncs, rememberMainCssSource, getRememberedMainCssSource, isViteProcessedCssAsset } = context;
 				const resolvedConfig = getResolvedConfig();
-				const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator);
-				const isWebGeneratorTarget = generatorOptions.target === "web";
 				const uniUtsPlatform = resolveUniUtsPlatform();
+				const generatorBranch = resolveGeneratorRuntimeBranch(normalizeWeappTailwindcssGeneratorOptions(opts.generator, {
+					appType: opts.appType,
+					platform: opts.cssOptions?.platform ?? opts.platform,
+					tailwindcssMajorVersion: runtimeState.tailwindRuntime.majorVersion,
+					uniAppX: opts.uniAppX,
+					uniUtsPlatform
+				}), {
+					appType: opts.appType,
+					platform: opts.cssOptions?.platform ?? opts.platform,
+					tailwindcssMajorVersion: runtimeState.tailwindRuntime.majorVersion,
+					uniAppX: opts.uniAppX,
+					uniUtsPlatform
+				});
+				const isWebGeneratorTarget = generatorBranch.isWeb;
 				const canInferHarmonyAppStyleTarget = !uniUtsPlatform.normalized || uniUtsPlatform.isApp;
 				const isHarmonyAppStyleTarget = uniUtsPlatform.isAppHarmony || canInferHarmonyAppStyleTarget && (isUniAppXHarmonyBundle(bundle) || isUniAppXHarmonyOutDir(resolvedConfig?.build?.outDir));
 				const isNativeAppStyleTarget = uniUtsPlatform.isApp || isHarmonyAppStyleTarget;
@@ -3760,13 +4253,14 @@ function createViteCssFinalizerOutputPlugin(context) {
 					const applyStyleSources = collectUniAppXHarmonyApplyStyleSources(bundle);
 					if (applyUtilities.size === 0 || applyStyleSources.length === 0) return cssSources;
 					const harmonyRuntime = new Set([...runtime, ...applyUtilities]);
-					const harmonyCssHandlerOptions = createCssHandlerOptions(opts, runtimeState.twPatcher.majorVersion, "uni-app-x-harmony-apply.css");
-					const generated = await generateCssByGenerator({
+					const harmonyCssHandlerOptions = createCssHandlerOptions(opts, runtimeState.tailwindRuntime.majorVersion, "uni-app-x-harmony-apply.css");
+					const generated = await generateTailwindV4Css({
 						opts,
 						runtimeState,
 						runtime: harmonyRuntime,
 						rawSource: createUniAppXHarmonyApplyGeneratorSource(applyStyleSources, applyUtilities),
 						file: "uni-app-x-harmony-apply.css",
+						outputFile: "uni-app-x-harmony-apply.css",
 						cssHandlerOptions: harmonyCssHandlerOptions,
 						cssUserHandlerOptions: {
 							...harmonyCssHandlerOptions,
@@ -3784,21 +4278,29 @@ function createViteCssFinalizerOutputPlugin(context) {
 					if (injectUniAppXHarmonyBundleStyles(bundle, { cssSources: await createHarmonyBundleStyleSources(runtime) })) debug("uni-app-x harmony bundle styles inject");
 				};
 				const isCssOutputAssetEntry = (entry) => {
-					const [, output] = entry;
-					return output.type === "asset" && opts.cssMatcher(output.fileName) && !isCssAssetProcessed(output, output.fileName);
+					const [bundleFile, output] = entry;
+					const fileName = output.fileName || bundleFile;
+					return output.type === "asset" && opts.cssMatcher(fileName) && !opts.htmlMatcher(fileName) && !isHTMLRequest(fileName) && !isCssAssetProcessed(output, fileName);
 				};
 				const entries = Object.entries(bundle).filter(isCssOutputAssetEntry);
 				if (entries.length === 0) {
 					await injectHarmonyBundleStyles(getRecordedGeneratorCandidates?.() ?? getSourceCandidates?.() ?? await ensureRuntimeClassSet());
 					collectViteProcessedCssAssets();
 					injectViteProcessedCssIntoMainCss();
+					normalizeTaroRootImportShellAssets(bundle, {
+						appType: opts.appType,
+						cssMatcher: opts.cssMatcher,
+						debug,
+						onUpdate: opts.onUpdate,
+						recordCssAssetResult
+					});
 					return;
 				}
 				await runtimeState.readyPromise;
 				await waitForSourceCandidateSyncs?.();
 				const runtime = getRecordedGeneratorCandidates?.() ?? getSourceCandidates?.() ?? await ensureRuntimeClassSet();
 				const collectedGeneratorCandidates = new Set([...runtime, ...getSourceCandidates?.() ?? []]);
-				const generatorRuntime = runtimeState.twPatcher.majorVersion === 4 && generatorOptions.target === "weapp" ? filterUnsupportedMiniProgramTailwindV4Candidates(collectedGeneratorCandidates) : collectedGeneratorCandidates;
+				const generatorRuntime = shouldUseMiniProgramCssBranch(generatorBranch) ? filterUnsupportedMiniProgramTailwindV4Candidates(collectedGeneratorCandidates) : collectedGeneratorCandidates;
 				await Promise.all(entries.map(async ([bundleFile, output]) => {
 					const file = output.fileName || bundleFile;
 					const rawSource = output.source.toString();
@@ -3810,7 +4312,7 @@ function createViteCssFinalizerOutputPlugin(context) {
 						debug("css finalizer skip vite-processed css: %s", file);
 						return;
 					}
-					const cssHandlerOptions = createCssHandlerOptions(opts, runtimeState.twPatcher.majorVersion, file);
+					const cssHandlerOptions = createCssHandlerOptions(opts, runtimeState.tailwindRuntime.majorVersion, file);
 					const cssUserHandlerOptions = {
 						...cssHandlerOptions,
 						isMainChunk: false
@@ -3819,24 +4321,25 @@ function createViteCssFinalizerOutputPlugin(context) {
 					const rememberedMainCssSource = processed && cssHandlerOptions.isMainChunk ? getRememberedMainCssSource?.(file) : void 0;
 					const generatorRawSource = rememberedMainCssSource?.rawSource ?? rawSource;
 					const generatorSourceFile = rememberedMainCssSource?.sourceFile ?? file;
-					const generatorCssHandlerOptions = rememberedMainCssSource ? createCssHandlerOptions(opts, runtimeState.twPatcher.majorVersion, generatorSourceFile) : cssHandlerOptions;
+					const generatorCssHandlerOptions = rememberedMainCssSource ? createCssHandlerOptions(opts, runtimeState.tailwindRuntime.majorVersion, generatorSourceFile) : cssHandlerOptions;
 					const generatorCssUserHandlerOptions = rememberedMainCssSource ? {
 						...generatorCssHandlerOptions,
 						isMainChunk: false
 					} : cssUserHandlerOptions;
-					const generated = shouldGenerateCssByGenerator(opts, file, generatorRawSource, processed) ? await generateCssByGenerator({
+					const generated = shouldGenerateCssByGenerator(opts, runtimeState.tailwindRuntime.majorVersion, file, generatorRawSource, processed) ? await generateTailwindV4Css({
 						opts,
 						runtimeState,
 						runtime: generatorRuntime,
 						rawSource: generatorRawSource,
 						file: generatorSourceFile,
+						outputFile: file,
 						cssHandlerOptions: generatorCssHandlerOptions,
 						cssUserHandlerOptions: generatorCssUserHandlerOptions,
 						getSourceCandidatesForEntries,
 						styleHandler: opts.styleHandler,
 						debug
 					}) : void 0;
-					const nextCss = annotateCss(generated?.css ?? (generatorOptions.target === "web" ? rawSource : (await opts.styleHandler(rawSource, cssHandlerOptions)).css));
+					const nextCss = annotateCss(generated?.css ?? (generatorBranch.isWeb ? rawSource : (await opts.styleHandler(rawSource, cssHandlerOptions)).css));
 					if (generated) {
 						registerGeneratorDependencies(this, generated.dependencies);
 						debug("css finalizer generated result: %s bytes=%d", file, nextCss.length);
@@ -3851,6 +4354,13 @@ function createViteCssFinalizerOutputPlugin(context) {
 				await injectHarmonyBundleStyles(generatorRuntime);
 				collectViteProcessedCssAssets();
 				injectViteProcessedCssIntoMainCss();
+				normalizeTaroRootImportShellAssets(bundle, {
+					appType: opts.appType,
+					cssMatcher: opts.cssMatcher,
+					debug,
+					onUpdate: opts.onUpdate,
+					recordCssAssetResult
+				});
 			}
 		}
 	};
@@ -3875,6 +4385,27 @@ const VITE_REMEMBERED_CSS_CACHE_MAX = 96;
 const VITE_KNOWN_SFC_SOURCE_CACHE_MAX = 128;
 const SFC_STYLE_BLOCK_RE = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
 const SFC_COMPONENT_FILE_RE = /\.(?:vue|uvue|nvue|svelte|mpx)$/i;
+function toMb$1(bytes) {
+	return Math.round(bytes / 1024 / 1024);
+}
+function summarizeStringMapCache(map) {
+	let bytes = 0;
+	for (const value of map.values()) bytes += value.length;
+	return {
+		bytes,
+		mb: toMb$1(bytes),
+		size: map.size
+	};
+}
+function summarizeRememberedCssSources(map) {
+	let bytes = 0;
+	for (const value of map.values()) bytes += value.rawSource.length;
+	return {
+		bytes,
+		mb: toMb$1(bytes),
+		size: map.size
+	};
+}
 function stripSourceHash(sourceFile) {
 	const hashIndex = sourceFile.indexOf("#");
 	return hashIndex === -1 ? sourceFile : sourceFile.slice(0, hashIndex);
@@ -3983,12 +4514,24 @@ function createViteCssMemory(options) {
 		if (SFC_COMPONENT_FILE_RE.test(file)) return getKnownSfcSource(file);
 		if (isSourceStyleRequest(file)) return options.getSourceCandidateSource(file);
 	};
+	const resolveCurrentStyleSource = async (sourceFile) => {
+		const cached = resolveCachedStyleSource(sourceFile);
+		if (cached != null) return cached;
+		const file = cleanUrl(stripRequestQuery(sourceFile));
+		if (!isSourceStyleRequest(file)) return;
+		try {
+			return await readFile(file, "utf8");
+		} catch (error) {
+			options.debug("refresh remembered css source read failed: %s %O", file, error);
+			return;
+		}
+	};
 	const refreshRememberedCssSourceByCurrentFile = async (sourceFile) => {
 		const file = cleanUrl(sourceFile);
 		const normalizedSourceFile = normalizeOutputPathKey(file);
 		const matchedRememberedSources = [...rememberedCssSources.values()].filter((remembered) => normalizeOutputPathKey(stripRequestQuery(cleanUrl(remembered.sourceFile))) === normalizedSourceFile);
 		if (matchedRememberedSources.length === 0) return;
-		const source = resolveCachedStyleSource(file);
+		const source = await resolveCurrentStyleSource(file);
 		if (source == null) {
 			options.debug("refresh remembered css source skipped: missing cached source for %s", file);
 			return;
@@ -4007,7 +4550,7 @@ function createViteCssMemory(options) {
 		const file = cleanUrl(stripRequestQuery(remembered.sourceFile));
 		const rememberedKey = [...rememberedCssSources.entries()].find(([, entry]) => entry === remembered)?.[0];
 		if (!rememberedKey || !path.isAbsolute(file)) return;
-		const source = resolveCachedStyleSource(file);
+		const source = await resolveCurrentStyleSource(file);
 		if (source == null) {
 			options.debug("refresh remembered css source before bundle replay skipped: missing cached source for %s", file);
 			return;
@@ -4045,8 +4588,10 @@ function createViteCssMemory(options) {
 		getRememberedCssSources: () => rememberedCssSources,
 		getStats: () => ({
 			rememberedCssSources: rememberedCssSources.size,
+			rememberedCssSourcesRaw: summarizeRememberedCssSources(rememberedCssSources),
 			rememberedCssSignatureByFile: rememberedCssSignatureByFile.size,
-			knownSfcSources: knownSfcSources.size
+			knownSfcSources: knownSfcSources.size,
+			knownSfcSourcesRaw: summarizeStringMapCache(knownSfcSources)
 		}),
 		rememberCssSource,
 		rememberKnownSfcSource,
@@ -4233,18 +4778,25 @@ function createRewriteCssImportsPlugins(options) {
 		async transform(code, id) {
 			if (!isCSSRequest(id)) return null;
 			const file = cleanUrl(id);
-			const normalizedCode = hasTailwindRootDirectives(code) ? normalizeTailwindConfigDirectives(code, path.dirname(file)) : code;
+			const normalizedCode = hasTailwindRootDirectives(code) || code.includes("@config") ? normalizeTailwindConfigDirectives(code, path.dirname(file)) : code;
 			await options.onCssSourceTransform?.(id, normalizedCode);
 			const hasTailwindRoot = hasTailwindRootDirectives(normalizedCode);
 			if (hasTailwindRoot) await options.onTailwindRootCss?.(id, normalizedCode);
-			if (options.shouldOwnTailwindGeneration && (hasTailwindRoot || options.shouldGenerateCss?.(id, normalizedCode))) {
+			const shouldGenerateInPreTransform = !options.shouldDeferGeneration?.(id, normalizedCode) && (hasTailwindRoot || options.shouldGenerateCss?.(id, normalizedCode));
+			if (options.shouldOwnTailwindGeneration && shouldGenerateInPreTransform) {
 				const generatedCss = await options.generateTailwindCss?.(id, normalizedCode, this);
 				if (generatedCss !== void 0) return {
 					code: generatedCss,
 					map: null
 				};
 			}
-			if (!options.shouldRewrite) return null;
+			if (!options.shouldRewrite) {
+				if (normalizedCode !== code) return {
+					code: normalizedCode,
+					map: null
+				};
+				return null;
+			}
 			const rewritten = rewriteTailwindcssImportsInCode(normalizedCode, weappTailwindcssDirPosix, {
 				join: joinPosixPath,
 				appType: resolveAppType(),
@@ -4265,11 +4817,11 @@ function hasVitePipelineTailwindGenerationDirective(code) {
 //#endregion
 //#region src/bundlers/vite/runtime-class-set.ts
 function createViteRuntimeClassSet(options) {
-	const { opts, initialTwPatcher, refreshTailwindcssPatcher, uniAppXEnabled, customAttributesEntities, disabledDefaultTemplateHandler, debug } = options;
+	const { opts, initialTailwindRuntime, refreshTailwindcssRuntime, uniAppXEnabled, customAttributesEntities, disabledDefaultTemplateHandler, debug } = options;
 	const runtimeState = {
-		twPatcher: initialTwPatcher,
-		readyPromise: createTailwindRuntimeReadyPromise(initialTwPatcher),
-		refreshTailwindcssPatcher
+		tailwindRuntime: initialTailwindRuntime,
+		readyPromise: createTailwindRuntimeReadyPromise(initialTailwindRuntime),
+		refreshTailwindcssRuntime
 	};
 	const bundleRuntimeClassSetManager = createBundleRuntimeClassSetManager({
 		bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues,
@@ -4284,8 +4836,8 @@ function createViteRuntimeClassSet(options) {
 	let runtimeRefreshSignature;
 	let runtimeRefreshOptionsKey;
 	function resolveRuntimeRefreshOptions() {
-		const configPath = resolveTailwindcssOptions(runtimeState.twPatcher.options)?.config;
-		const signature = getRuntimeClassSetSignature(runtimeState.twPatcher);
+		const configPath = resolveTailwindcssOptions(runtimeState.tailwindRuntime.options)?.config;
+		const signature = getRuntimeClassSetSignature(runtimeState.tailwindRuntime);
 		const optionsKey = JSON.stringify({
 			appType: opts.appType,
 			uniAppX: uniAppXEnabled,
@@ -4321,7 +4873,7 @@ function createViteRuntimeClassSet(options) {
 		if (!forceRuntimeRefresh && runtimeSet) return runtimeSet;
 		if (forceRuntimeRefresh || !runtimeSetPromise) {
 			const invalidation = resolveRuntimeRefreshOptions();
-			runtimeSetPromise = collectRuntimeClassSet(runtimeState.twPatcher, {
+			runtimeSetPromise = collectRuntimeClassSet(runtimeState.tailwindRuntime, {
 				force: forceRuntimeRefresh || invalidation.changed,
 				skipRefresh: forceRuntimeRefresh,
 				clearCache: forceRuntimeRefresh || invalidation.changed
@@ -4335,54 +4887,29 @@ function createViteRuntimeClassSet(options) {
 			if (runtimeSetPromise === task) runtimeSetPromise = void 0;
 		}
 	}
-	async function ensureBundleRuntimeClassSet(snapshot, forceRefresh = false, options = {}) {
+	async function ensureBundleRuntimeClassSet(snapshot, forceRefresh = false, _options = {}) {
 		const forceRuntimeRefresh = forceRefresh || process$1.env["WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH"] === "1";
 		const invalidation = resolveRuntimeRefreshOptions();
-		const shouldRefreshPatcher = forceRuntimeRefresh || invalidation.changed;
+		const shouldRefreshRuntime = forceRuntimeRefresh || invalidation.changed;
 		const forceCollectBySource = snapshot.runtimeAffectingChangedByType.html.size > 0 || snapshot.runtimeAffectingChangedByType.js.size > 0;
-		await refreshRuntimeState(shouldRefreshPatcher);
+		await refreshRuntimeState(shouldRefreshRuntime);
 		await runtimeState.readyPromise;
-		if (shouldRefreshPatcher) {
+		if (shouldRefreshRuntime) {
 			runtimeSet = void 0;
 			runtimeSetPromise = void 0;
 			await bundleRuntimeClassSetManager.reset();
 			await transformRuntimeClassSetManager.reset();
 		}
-		if (runtimeState.twPatcher.majorVersion === 4 && !forceRuntimeRefresh) try {
-			const nextRuntimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.twPatcher, snapshot);
+		if (!forceRuntimeRefresh) try {
+			const nextRuntimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.tailwindRuntime, snapshot);
 			runtimeSet = nextRuntimeSet;
 			return nextRuntimeSet;
 		} catch (error) {
 			debug("incremental runtime set sync failed, fallback to full collect: %O", error);
 			await bundleRuntimeClassSetManager.reset();
 		}
-		if (runtimeState.twPatcher.majorVersion === 3 && !forceRuntimeRefresh) {
-			if (options.transformOnly) try {
-				return await transformRuntimeClassSetManager.sync(runtimeState.twPatcher, snapshot);
-			} catch (error) {
-				debug("incremental transform runtime set sync failed, fallback to full collect: %O", error);
-				await transformRuntimeClassSetManager.reset();
-			}
-			try {
-				let baseClassSet = options.baseClassSet;
-				if (!baseClassSet && (!runtimeSet || shouldRefreshPatcher)) baseClassSet = await collectRuntimeClassSet(runtimeState.twPatcher, {
-					force: true,
-					skipRefresh: shouldRefreshPatcher,
-					clearCache: shouldRefreshPatcher
-				});
-				const nextRuntimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.twPatcher, snapshot, {
-					baseClassSet: baseClassSet ?? (options.allowBaselineOnlyInitialSync === true ? runtimeSet : void 0),
-					skipInitialFullScanWithBase: options.allowBaselineOnlyInitialSync === true && Boolean(runtimeSet)
-				});
-				runtimeSet = nextRuntimeSet;
-				return nextRuntimeSet;
-			} catch (error) {
-				debug("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, {
+		const task = collectRuntimeClassSet(runtimeState.tailwindRuntime, {
 			force: forceRuntimeRefresh || invalidation.changed || forceCollectBySource,
 			skipRefresh: forceRuntimeRefresh,
 			clearCache: forceRuntimeRefresh || invalidation.changed
@@ -4480,35 +5007,6 @@ function createViteServeCssGenerationPlugins(options) {
 	}];
 }
 //#endregion
-//#region src/bundlers/vite/source-candidate-scan-signature.ts
-function normalizeSignaturePath(value) {
-	return slash(path.resolve(value));
-}
-function serializeInlineCandidates(inlineCandidates) {
-	return {
-		excluded: [...inlineCandidates?.excluded ?? []].sort(),
-		included: [...inlineCandidates?.included ?? []].sort()
-	};
-}
-function serializeSourceEntries(entries) {
-	return (entries ?? []).map((entry) => ({
-		base: normalizeSignaturePath(entry.base),
-		negated: entry.negated,
-		pattern: entry.pattern
-	})).sort((a, b) => `${a.base}\0${a.pattern}\0${a.negated}`.localeCompare(`${b.base}\0${b.pattern}\0${b.negated}`));
-}
-function createSourceCandidateScanSignature(input) {
-	return JSON.stringify({
-		inlineCandidates: serializeInlineCandidates(input.inlineCandidates),
-		outDir: input.outDir ? normalizeSignaturePath(input.outDir) : void 0,
-		roots: input.roots.map((root) => ({
-			entries: serializeSourceEntries(root.entries),
-			root: normalizeSignaturePath(root.root)
-		})),
-		scanAllSources: input.scanAllSources ?? false
-	});
-}
-//#endregion
 //#region src/bundlers/vite/tailwind-basedir.ts
 const PACKAGE_JSON_FILE = "package.json";
 function resolveImplicitTailwindcssBasedirFromViteRoot(root) {
@@ -4535,9 +5033,33 @@ const weappTailwindcssPackageDir = resolvePackageDir("weapp-tailwindcss");
 const weappTailwindcssDirPosix = slash(weappTailwindcssPackageDir);
 const SOURCE_CANDIDATE_SCAN_CACHE_MAX = 8;
 const sourceCandidateScanSnapshotCache = new LRUCache({ max: SOURCE_CANDIDATE_SCAN_CACHE_MAX });
+function isMissingInternalCssSource(file) {
+	return !existsSync(file) && path.resolve(file).startsWith(`${weappTailwindcssPackageDir}${path.sep}`);
+}
 function normalizeVitePersistentCacheKey(file) {
 	return normalizeOutputPathKey(file);
 }
+function toMb(bytes) {
+	return Math.round(bytes / 1024 / 1024);
+}
+function summarizeStringCache(map) {
+	let bytes = 0;
+	for (const value of map.values()) bytes += value.length;
+	return {
+		bytes,
+		mb: toMb(bytes),
+		size: map.size
+	};
+}
+function summarizeViteProcessedCssResults(map) {
+	let bytes = 0;
+	for (const record of map.values()) bytes += record.css.length;
+	return {
+		bytes,
+		mb: toMb(bytes),
+		size: map.size
+	};
+}
 /**
 * @name WeappTailwindcss
 * @description uni-app vite / uni-app-x 版本插件
@@ -4558,14 +5080,28 @@ function WeappTailwindcss(options = {}) {
 		(_opts$tailwindcss = opts.tailwindcss).v4 ?? (_opts$tailwindcss.v4 = {});
 		(_opts$tailwindcss$v = opts.tailwindcss.v4).cssEntries ?? (_opts$tailwindcss$v.cssEntries = opts.cssEntries);
 	}
-	const { disabled, customAttributes, onLoad, mainCssChunkMatcher, styleHandler, jsHandler, twPatcher: initialTwPatcher, refreshTailwindcssPatcher, uniAppX, disabledDefaultTemplateHandler } = opts;
+	const { disabled, customAttributes, onLoad, mainCssChunkMatcher, styleHandler, jsHandler, tailwindRuntime, refreshTailwindcssRuntime, uniAppX, disabledDefaultTemplateHandler } = opts;
+	const initialTailwindRuntime = tailwindRuntime;
+	const refreshTailwindRuntime = refreshTailwindcssRuntime;
 	const uniAppXEnabled = isUniAppXEnabled(uniAppX);
 	const disabledOptions = resolvePluginDisabledState(disabled);
-	const tailwindcssMajorVersion = initialTwPatcher.majorVersion ?? 0;
+	const tailwindcssMajorVersion = initialTailwindRuntime.majorVersion ?? 0;
+	if (!disabledOptions.plugin && tailwindcssMajorVersion !== 4) throw new Error("weapp-tailwindcss/vite 新生成管线仅支持 Tailwind CSS v4，请升级 tailwindcss 或停留在旧版 weapp-tailwindcss。");
 	const shouldOwnTailwindGeneration = !disabledOptions.plugin;
-	const shouldRewriteCssImports = tailwindcssMajorVersion >= 4;
-	const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator);
-	const shouldInferAppType = !hasExplicitAppType && generatorOptions.target !== "web";
+	const shouldRewriteCssImports = opts.rewriteCssImports === true;
+	const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator, {
+		appType: opts.appType,
+		platform: opts.cssOptions?.platform ?? opts.platform,
+		tailwindcssMajorVersion,
+		uniAppX
+	});
+	const generatorBranch = resolveGeneratorRuntimeBranch(generatorOptions, {
+		appType: opts.appType,
+		platform: opts.cssOptions?.platform ?? opts.platform,
+		tailwindcssMajorVersion,
+		uniAppX
+	});
+	const shouldInferAppType = !hasExplicitAppType && !generatorBranch.isWeb;
 	const hasInitialTailwindCssRoots = hasConfiguredTailwindV4CssRoots({
 		...options,
 		cssEntries: opts.cssEntries ?? options.cssEntries
@@ -4576,13 +5112,16 @@ function WeappTailwindcss(options = {}) {
 	let autoCssSourcesRefresh;
 	let autoCssSourcesDiscovered = false;
 	const syncTailwindCssSourceCandidates = async (id, css) => {
+		if (tailwindcssMajorVersion === 4 && isMissingInternalCssSource(cleanUrl(id))) return;
 		await sourceCandidateCollector.syncCss(id, css);
 		cacheCurrentSourceCandidateScan();
 	};
 	const registerAutoCssSource = async (id, css, options = {}) => {
-		if (tailwindcssMajorVersion < 4 || !shouldOwnTailwindGeneration) return;
+		if (!shouldOwnTailwindGeneration) return;
 		const file = cleanUrl(id);
 		if (!path.isAbsolute(file)) return;
+		if (!isTailwindV4CssEntry(file)) return;
+		if (isMissingInternalCssSource(file)) return;
 		const sourceFile = path.normalize(file);
 		const sourceBase = path.dirname(sourceFile);
 		const sourceCss = normalizeTailwindSourceForGenerator(normalizeTailwindConfigDirectives(css, sourceBase), { importFallback: true });
@@ -4618,7 +5157,7 @@ function WeappTailwindcss(options = {}) {
 		await autoCssSourcesRefresh;
 	};
 	const discoverAndRegisterAutoCssSources = async () => {
-		if (tailwindcssMajorVersion < 4 || !shouldOwnTailwindGeneration || hasInitialTailwindCssRoots || !resolvedConfig?.root) return;
+		if (!shouldOwnTailwindGeneration || hasInitialTailwindCssRoots || !resolvedConfig?.root) return;
 		const cssEntries = await discoverTailwindV4CssEntries(resolvedConfig.root, resolvedConfig.build?.outDir);
 		autoCssSourcesDiscovered = true;
 		let changed = false;
@@ -4643,11 +5182,7 @@ function WeappTailwindcss(options = {}) {
 	const customAttributesEntities = toCustomAttributesEntities(customAttributes);
 	let resolvedConfig;
 	let recordedGeneratorCandidates;
-	const sourceCandidateExtractor = tailwindcssMajorVersion === 3 ? createTailwindV3DefaultExtractor() : void 0;
-	const sourceCandidateCollector = createSourceCandidateCollector({
-		bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues,
-		extractor: sourceCandidateExtractor
-	});
+	const sourceCandidateCollector = createSourceCandidateCollector({ bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues });
 	const sourceCandidateScanCache = new LRUCache({ max: SOURCE_CANDIDATE_SCAN_CACHE_MAX });
 	let sourceScanEntries;
 	let sourceScanMatcher;
@@ -4668,8 +5203,8 @@ function WeappTailwindcss(options = {}) {
 	const tailwindRootCssModuleIds = /* @__PURE__ */ new Set();
 	const { runtimeState, refreshRuntimeState, ensureRuntimeClassSet, ensureBundleRuntimeClassSet } = createViteRuntimeClassSet({
 		opts,
-		initialTwPatcher,
-		refreshTailwindcssPatcher,
+		initialTailwindRuntime,
+		refreshTailwindcssRuntime: refreshTailwindRuntime,
 		uniAppXEnabled,
 		customAttributesEntities,
 		disabledDefaultTemplateHandler,
@@ -4726,6 +5261,7 @@ function WeappTailwindcss(options = {}) {
 			seenRoots.add(basedir);
 		}
 		for (const cssEntry of opts.tailwindcss?.v4?.cssEntries ?? []) {
+			if (!isTailwindV4CssEntry(cssEntry)) continue;
 			const cssEntryRoot = path.dirname(path.resolve(cssEntry));
 			if (seenRoots.has(cssEntryRoot)) continue;
 			roots.push({ root: cssEntryRoot });
@@ -4760,7 +5296,7 @@ function WeappTailwindcss(options = {}) {
 		}
 		const root = resolvedConfig?.root ?? process$1.cwd();
 		const outDir = resolvedConfig?.build?.outDir;
-		const sourceScan = await resolveViteSourceScanEntries(opts, runtimeState.twPatcher, {
+		const sourceScan = await resolveViteSourceScanEntries(opts, runtimeState.tailwindRuntime, {
 			outDir,
 			root
 		});
@@ -4811,6 +5347,9 @@ function WeappTailwindcss(options = {}) {
 		if (sourceScanMatcher && !sourceScanMatcher(file)) {
 			sourceCandidateCollector.remove(file);
 			cacheCurrentSourceCandidateScan();
+			if (isSourceStyleRequest(file)) return readFile(file, "utf8").then((source) => cssMemory.refreshRememberedCssSourceBySourceFile(file, source)).catch((error) => {
+				if ((typeof error === "object" && error !== null && "code" in error ? error.code : void 0) !== "ENOENT") debug("remembered css source watch refresh failed: %s %O", file, error);
+			}).then(() => cssMemory.refreshRememberedCssSourceByCurrentFile(file)).then(() => void 0);
 			return cssMemory.refreshRememberedCssSourceByCurrentFile(file);
 		}
 		const existingTask = pendingSourceCandidateSyncByFile.get(file);
@@ -4843,7 +5382,9 @@ function WeappTailwindcss(options = {}) {
 	const getViteProcessedCssAssetResult = (file) => viteProcessedCssAssetResults.get(normalizeVitePersistentCacheKey(file));
 	const getViteCssCacheStats = () => ({
 		viteGeneratedCssByFile: viteGeneratedCssByFile.size,
+		viteGeneratedCssByFileRaw: summarizeStringCache(viteGeneratedCssByFile),
 		viteProcessedCssAssetResults: viteProcessedCssAssetResults.size,
+		viteProcessedCssAssetResultsRaw: summarizeViteProcessedCssResults(viteProcessedCssAssetResults),
 		...cssMemory.getStats(),
 		sourceCandidateScanCache: sourceCandidateScanCache.size,
 		pendingSourceCandidateSyncs: pendingSourceCandidateSyncs.size,
@@ -4889,7 +5430,7 @@ function WeappTailwindcss(options = {}) {
 	const transformCssHandlerOptions = createCssHandlerOptionsCache({
 		getAppType: () => opts.appType,
 		mainCssChunkMatcher,
-		getMajorVersion: () => runtimeState.twPatcher.majorVersion,
+		getMajorVersion: () => runtimeState.tailwindRuntime.majorVersion,
 		getOutputRoot: () => resolvedConfig?.build?.outDir ? path.resolve(resolvedConfig.root, resolvedConfig.build.outDir) : resolvedConfig?.root,
 		getExtraOptions: (file) => ({
 			...resolveViteCssHandlerExtraOptions(file),
@@ -4901,11 +5442,13 @@ function WeappTailwindcss(options = {}) {
 		await runtimeState.readyPromise;
 		await waitForSourceCandidateSyncs();
 		const file = cleanUrl(id);
+		const requestFile = isCSSRequest(id) ? id : file;
+		if (!isCSSRequest(requestFile) || opts.htmlMatcher(file) || isHTMLRequest(file)) return;
 		const rootDir = resolvedConfig?.root ? path.resolve(resolvedConfig.root) : process$1.cwd();
 		const isHarmonyAppStyleTarget = isHarmonyAppBuildTarget();
 		const isNativeAppStyleTarget = resolveUniUtsPlatform().isApp || isHarmonyAppStyleTarget;
 		const sourceRoot = resolveWeappViteSourceRoot(resolvedConfig, opts.appType);
-		const outputFile = resolveViteCssPipelineOutputFile(file, opts, rootDir, generatorOptions.target === "web", isNativeAppStyleTarget, sourceRoot);
+		const outputFile = resolveViteCssPipelineOutputFile(requestFile, opts, rootDir, generatorBranch.isWeb, isNativeAppStyleTarget, sourceRoot);
 		const runtime = getRecordedGeneratorCandidates() ?? getSourceCandidates() ?? await ensureRuntimeClassSet();
 		const outputCssHandlerOptions = transformCssHandlerOptions.getCssHandlerOptions(outputFile);
 		const cssHandlerOptions = {
@@ -4914,12 +5457,13 @@ function WeappTailwindcss(options = {}) {
 		};
 		const transientCssSource = transientAutoCssSources.get(file);
 		const shouldDeferEmptyScopedCssSource = transientCssSource == null && !(opts.appType === "uni-app-x" && !cssHandlerOptions.isMainChunk && hasTailwindApplyDirective(code));
-		const generated = await generateCssByGenerator({
+		const generated = await generateTailwindV4Css({
 			opts,
 			runtimeState,
 			runtime,
 			rawSource: code,
 			file,
+			outputFile,
 			cssHandlerOptions,
 			cssUserHandlerOptions: transformCssHandlerOptions.getCssUserHandlerOptions(file),
 			cssSources: transientCssSource ? [transientCssSource] : void 0,
@@ -4968,6 +5512,7 @@ function WeappTailwindcss(options = {}) {
 		onTailwindRootCss: (id, code) => registerAutoCssSource(id, code),
 		onCssSourceTransform: (id, code) => cssMemory.refreshRememberedCssSourceBySourceFile(id, code),
 		shouldGenerateCss: (_id, code) => hasVitePipelineTailwindGenerationDirective(code),
+		shouldDeferGeneration: (_id, code) => !shouldRewriteCssImports && hasTailwindRootDirectives(code, { importFallback: generatorOptions.importFallback }),
 		shouldOwnTailwindGeneration,
 		shouldRewrite: shouldRewriteCssImports,
 		weappTailwindcssDirPosix
@@ -5167,11 +5712,6 @@ function WeappTailwindcss(options = {}) {
 							const removed = removeTailwindPostcssPlugins(postcssPlugins);
 							if (removed > 0) debug("remove official tailwind postcss plugins in generator mode: %d", removed);
 						}
-						const idx = postcssPlugins.findIndex((x) => getPostcssPluginName(x) === "postcss-html-transform");
-						if (idx > -1) {
-							postcssPlugins.splice(idx, 1, postcssHtmlTransform());
-							debug("remove postcss-html-transform plugin from vite config");
-						}
 					}
 				}, { emit: false });
 			},