weapp-tailwindcss 5.0.6 → 5.0.8

package/dist/{vite-ChZ2cbn4.mjs → vite-_iUhzc4t.mjs}

@@ -1,23 +1,28 @@
-import { C as hasLocalCssImport, D as normalizeTailwindConfigDirectives, E as hasTailwindSourceDirectives, L as hasTailwindGeneratedCssMarkers, M as removeTailwindSourceDirectives, T as hasTailwindRootDirectives, Y as filterUnsupportedMiniProgramTailwindV4Candidates, _ as resolveViteSourceScanEntries, _t as findNearestPackageRoot, ft as findTailwindConfig, g as resolveTailwindV4EntriesFromCssCached, gt as omitUndefined, j as parseImportRequest, k as normalizeTailwindSourceForGenerator, l as getRuntimeClassSetSignature, lt as createDebug, m as discoverTailwindV4CssEntries, p as createViteSourceScanMatcher, pt as resolveTailwindcssOptions, st as resolveTailwindV4CssSourceBase, v as resolveViteTailwindV4CssDependencies, w as hasTailwindApplyDirective } from "./v3-engine-Ji6AXPh2.mjs";
-import { i as normalizeWeappTailwindcssGeneratorOptions } from "./generator-Bgn4m8An.mjs";
-import { _ as collectRuntimeClassSet, a as vitePluginName, b as refreshTailwindRuntimeState, g as toCustomAttributesEntities, n as getCompilerContext, t as shouldSkipJsTransform, v as createTailwindRuntimeReadyPromise } from "./precheck-Copn2SqE.mjs";
+import { C as hasLocalCssImport, D as normalizeTailwindConfigDirectives, E as hasTailwindSourceDirectives, L as hasTailwindGeneratedCssMarkers, M as removeTailwindSourceDirectives, T as hasTailwindRootDirectives, Y as filterUnsupportedMiniProgramTailwindV4Candidates, _ as resolveTailwindV4EntriesFromCssCached, ft as findTailwindConfig, gt as findNearestPackageRoot, h as discoverTailwindV4CssEntries, j as parseImportRequest, k as normalizeTailwindSourceForGenerator, l as getRuntimeClassSetSignature, lt as createDebug, m as resolveViteSourceScanEntries, ot as resolveTailwindV4CssSourceBase, p as createViteSourceScanMatcher, pt as resolveTailwindcssOptions, v as resolveViteTailwindV4CssDependencies, w as hasTailwindApplyDirective, yt as omitUndefined } from "./v3-engine-ArQVHEau.mjs";
+import { i as normalizeWeappTailwindcssGeneratorOptions } from "./generator-DnwUQOXB.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-CcxTR7E_.mjs";
 import { o as resolveUniUtsPlatform } from "./utils-DsaS975I.mjs";
-import { a as normalizeCssEntries, c as hasConfiguredTailwindV4CssRoots, i as resolveUniAppXOptions, l as upsertTailwindV4CssSource, r as isUniAppXEnabled } from "./tailwindcss-C0Zgo3Es.mjs";
-import { a as validateCandidatesByGenerator, i as generateCssByGenerator, n as createHmrTimingRecorder, o as mergeMarkedUserLayerComponentsCss, s as processCachedTask, t as createBundleRuntimeClassSetManager } from "./incremental-runtime-class-set-BEYHQkZc.mjs";
-import { n as createTailwindV3DefaultExtractor, r as isSourceCandidateRequest, t as createSourceCandidateCollector } from "./source-candidates-BODCmzz5.mjs";
-import { C as toAbsoluteOutputPath, _ as normalizePath, a as applyLinkedResults, b as stripRequestQuery, c as createBundlerGeneratedCssMarker, d as stripBundlerGeneratedCssMarkers, f as resolvePackageDir, g as isCSSRequest, h as formatPostcssSourceMap, i as createRuntimeAffectingSourceSignature, l as hasBundlerGeneratedCssMarker, m as cleanUrl, n as createBundleBuildState, o as createBundleModuleGraphOptions, p as resolvePluginDisabledState, r as updateBundleBuildState, s as pushConcurrentTaskFactories, t as buildBundleSnapshot, u as parseBundlerGeneratedCssMarkerBlocks, v as slash, x as normalizeOutputPathKey, y as isSourceStyleRequest } from "./bundle-state-CdNXQl-o.mjs";
+import { a as normalizeCssEntries, c as hasConfiguredTailwindV4CssRoots, i as resolveUniAppXOptions, l as upsertTailwindV4CssSource, r as isUniAppXEnabled } from "./tailwindcss-0DaftXcU.mjs";
+import { a as createTailwindV3DefaultExtractor, c as validateCandidatesByGenerator, g as createCssTokenSourceMap, h as createCssSourceTraceCacheSignature, i as isSourceCandidateRequest, l as extractMarkedUserLayerComponentsCss, m as annotateCssSourceTrace, o as createBundleRuntimeClassSetManager, r as createSourceCandidateCollector, s as generateCssByGenerator, t as createHmrTimingRecorder, u as mergeMarkedUserLayerComponentsCss, v as processCachedTask } from "./hmr-timing-DK-mine6.mjs";
+import { C as toAbsoluteOutputPath, _ as normalizePath, a as applyLinkedResults, b as stripRequestQuery, c as createBundlerGeneratedCssMarker, d as stripBundlerGeneratedCssMarkers, f as resolvePackageDir, g as isCSSRequest, h as formatPostcssSourceMap, i as createRuntimeAffectingSourceSignature, l as hasBundlerGeneratedCssMarker, m as cleanUrl, n as createBundleBuildState, o as createBundleModuleGraphOptions, p as resolvePluginDisabledState, r as updateBundleBuildState, s as pushConcurrentTaskFactories, t as buildBundleSnapshot, u as parseBundlerGeneratedCssMarkerBlocks, v as slash, x as normalizeOutputPathKey, y as isSourceStyleRequest } from "./bundle-state-5FtFktJr.mjs";
 import { t as logger$1 } from "./logger-BNzxZbZj.mjs";
-import fs, { existsSync, readFileSync } from "node:fs";
 import postcss from "postcss";
 import { splitCandidateTokens } from "tailwindcss-patch";
 import process$1 from "node:process";
+import fs, { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 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 { parse } from "comment-json";
+import selectorParser from "postcss-selector-parser";
 import postcssrc from "postcss-load-config";
+//#region src/uni-app-x/harmony.ts
+function isUniAppXHarmonyOutDir(outDir) {
+	return typeof outDir === "string" && /(?:^|[/\\])\.?app-harmony(?:[/\\]|$)/.test(outDir);
+}
+//#endregion
 //#region src/bundlers/vite/query.ts
 function parseVueRequest(id) {
 	const [filename = id, rawQuery] = id.split(`?`, 2);
@@ -37,6 +42,419 @@ function parseVueRequest(id) {
 	};
 }
 //#endregion
+//#region src/uni-app-x/style-asset/style-value.ts
+const GEN_APP_STYLES_RE = /const\s+GenAppStyles\s*=\s*\[_uM\(\[([\s\S]*?)\]\)\]/;
+const STYLE_ENTRY_RE = /\[\s*("((?:\\.|[^"\\])+)")\s*,\s*(_pS\(_uM\(\[[\s\S]*?\]\)\))\s*\]/g;
+const STRING_LITERAL_RE = /(['"`])((?:\\.|(?!\1)[\s\S])*?)\1/g;
+const SFC_STYLE_BLOCK_RE$2 = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+const STYLE_EXPORT_PREFIX_RE = /^\s*export\s+default\s+/;
+const CLASS_SELECTOR_PREFIX_RE = /^\.((?:\\[^\n\r\f]|[\w-])+)(?=$|[.:#[])/;
+function toCamelCase(prop) {
+	return prop.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+function normalizeValue(value) {
+	const trimmed = value.trim();
+	if (/^-?\d+(?:\.\d+)?px$/.test(trimmed)) return Number(trimmed.slice(0, -2));
+	return trimmed.replace(/\s*,\s*/g, ",");
+}
+function normalizeStyleValue(value) {
+	if (typeof value === "number") return value;
+	return normalizeValue(value);
+}
+function unescapeCssClassSelector(className) {
+	return className.replace(/\\([^\n\r\f0-9a-f])/gi, "$1");
+}
+function parseStyleExport(source) {
+	const json = source.replace(STYLE_EXPORT_PREFIX_RE, "").trim();
+	if (!json) return;
+	try {
+		return JSON.parse(json);
+	} catch {}
+}
+function parseStyleObject(source) {
+	try {
+		return JSON.parse(source);
+	} catch {}
+}
+function parseSourceMapSourcesContent(source) {
+	try {
+		const map = JSON.parse(source);
+		return Array.isArray(map.sourcesContent) ? map.sourcesContent.filter((item) => typeof item === "string") : [];
+	} catch {
+		return [];
+	}
+}
+function collectChunkMapSourcesContent(chunk) {
+	const map = chunk.map;
+	return Array.isArray(map?.sourcesContent) ? map.sourcesContent.filter((item) => typeof item === "string") : [];
+}
+function styleExportToUtsMap(styleExport) {
+	const classEntries = [];
+	for (const [className, styleStates] of Object.entries(styleExport)) {
+		const declarations = styleStates[""];
+		if (!declarations || Object.keys(declarations).length === 0) continue;
+		const declarationEntries = Object.entries(declarations).map(([prop, value]) => {
+			return `[${JSON.stringify(toCamelCase(prop))}, ${JSON.stringify(normalizeStyleValue(value))}]`;
+		});
+		if (declarationEntries.length === 0) continue;
+		classEntries.push(`[${JSON.stringify(className)}, _pS(_uM([${declarationEntries.join(", ")}]))]`);
+	}
+	if (classEntries.length === 0) return "[]";
+	return `[_uM([${classEntries.join(", ")}])]`;
+}
+function createUtsStyleArray(entries) {
+	if (entries.length === 0) return "[]";
+	return `[_uM([${entries.join(", ")}])]`;
+}
+function extractAppStyleEntries(source) {
+	const match = source.match(GEN_APP_STYLES_RE);
+	if (!match?.[1]) return;
+	const entries = /* @__PURE__ */ new Map();
+	for (const entry of match[1].matchAll(STYLE_ENTRY_RE)) {
+		const rawClassName = entry[1];
+		const className = entry[2];
+		const styleValue = entry[3];
+		if (!rawClassName || !className || !styleValue) continue;
+		entries.set(JSON.parse(rawClassName), `[${rawClassName}, ${styleValue}]`);
+	}
+	return entries.size > 0 ? entries : void 0;
+}
+function collectUsedClassNames(code, entries) {
+	const used = /* @__PURE__ */ new Set();
+	for (const literalMatch of code.matchAll(STRING_LITERAL_RE)) {
+		const literal = literalMatch[2];
+		if (!literal) continue;
+		for (const candidate of splitCandidateTokens(literal)) if (entries.has(candidate)) used.add(candidate);
+	}
+	return used;
+}
+function collectUsedStyleKeys(code, styleValue) {
+	return collectUsedClassNames(code, new Map(Object.keys(styleValue).map((className) => [className, className])));
+}
+function createUtsStyleArrayFromAppStyles(code, appSource) {
+	if (!appSource) return;
+	const entries = extractAppStyleEntries(appSource);
+	if (!entries) return;
+	const used = collectUsedClassNames(code, entries);
+	if (used.size === 0) return;
+	return createUtsStyleArray([...used].map((className) => entries.get(className)).filter(Boolean));
+}
+function cssToStyleExport(source) {
+	let root;
+	try {
+		root = postcss.parse(source);
+	} catch {
+		return;
+	}
+	const result = {};
+	root.walkRules((rule) => {
+		const selectors = rule.selectors ?? [];
+		for (const selector of selectors) {
+			const match = selector.trim().match(CLASS_SELECTOR_PREFIX_RE);
+			if (!match?.[1]) continue;
+			const declarations = {};
+			rule.walkDecls((decl) => {
+				declarations[toCamelCase(decl.prop)] = normalizeValue(decl.value);
+			});
+			if (Object.keys(declarations).length > 0) {
+				result[match[1]] = { "": declarations };
+				const className = unescapeCssClassSelector(match[1]);
+				result[className] = { "": declarations };
+				result[replaceWxml(className)] = { "": declarations };
+			}
+		}
+	});
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function cssSourceToStyleValue(source) {
+	return STYLE_EXPORT_PREFIX_RE.test(source) ? parseStyleExport(source) : cssToStyleExport(source);
+}
+function mergeStyleValues(...items) {
+	const result = {};
+	for (const item of items) {
+		if (!item) continue;
+		for (const [className, states] of Object.entries(item)) if (!result[className]) result[className] = states;
+	}
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function createStyleValueFromApplySources(sources, utilityStyles) {
+	if (!utilityStyles) return;
+	const result = {};
+	for (const source of sources) {
+		const styleSources = source.includes("<style") ? [...source.matchAll(SFC_STYLE_BLOCK_RE$2)].map((styleBlock) => styleBlock[1] ?? "") : [source];
+		for (const styleSource of styleSources) {
+			let root;
+			try {
+				root = postcss.parse(styleSource);
+			} catch {
+				continue;
+			}
+			root.walkRules((rule) => {
+				const applyRules = rule.nodes?.filter((node) => node.type === "atrule" && node.name === "apply") ?? [];
+				if (applyRules.length === 0) return;
+				const selectors = rule.selectors ?? [rule.selector];
+				for (const selector of selectors) {
+					const className = selector.trim().match(CLASS_SELECTOR_PREFIX_RE)?.[1];
+					if (!className) continue;
+					const declarations = {};
+					for (const applyRule of applyRules) for (const utility of splitCandidateTokens(applyRule.params)) {
+						const utilityDeclarations = utilityStyles[utility]?.[""] ?? utilityStyles[replaceWxml(utility)]?.[""];
+						if (utilityDeclarations) Object.assign(declarations, utilityDeclarations);
+					}
+					if (Object.keys(declarations).length > 0) {
+						const unescapedClassName = unescapeCssClassSelector(className);
+						result[className] = { "": declarations };
+						result[unescapedClassName] = { "": declarations };
+						result[replaceWxml(unescapedClassName)] = { "": declarations };
+					}
+				}
+			});
+		}
+	}
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function collectUniAppXHarmonyApplyStyleSourcesFromSource(source) {
+	return (source.includes("<style") ? [...source.matchAll(SFC_STYLE_BLOCK_RE$2)].map((styleBlock) => styleBlock[1] ?? "") : [source]).map((styleSource) => styleSource.trim()).filter((styleSource) => styleSource.length > 0 && styleSource.includes("@apply"));
+}
+function collectUniAppXHarmonyApplyUtilitiesFromSources(sources) {
+	const utilities = /* @__PURE__ */ new Set();
+	for (const source of sources) for (const styleSource of collectUniAppXHarmonyApplyStyleSourcesFromSource(source)) {
+		let root;
+		try {
+			root = postcss.parse(styleSource);
+		} catch {
+			continue;
+		}
+		root.walkAtRules("apply", (rule) => {
+			for (const utility of splitCandidateTokens(rule.params)) utilities.add(utility);
+		});
+	}
+	return utilities;
+}
+function createMergedStyleValue(code, localStyle, appStyle) {
+	const used = collectUsedStyleKeys(code, appStyle);
+	if (used.size === 0) return;
+	const merged = { ...localStyle ?? {} };
+	let changed = false;
+	for (const className of used) {
+		if (merged[className] || !appStyle[className]) continue;
+		merged[className] = appStyle[className];
+		changed = true;
+	}
+	return changed ? merged : void 0;
+}
+//#endregion
+//#region src/uni-app-x/style-asset.ts
+const GEN_STYLES_PLACEHOLDER_RE = /\/\*(Gen[A-Za-z0-9]+Styles)\*\/|const\s+(Gen[A-Za-z0-9]+Styles)\s*=\s*\[\]/;
+const UVUE_TS_RE = /\.uvue\.ts$/;
+const JS_RE = /\.js$/;
+const APP_JS_RE = /(?:^|\/)App\.js$/;
+const COMPONENT_JS_RE = /(?:^|\/)components\/.+\.js$/;
+const HARMONY_BUNDLE_MARKER_FILES = new Set([
+	"import/app-service.ets",
+	"import/dynamic.ets",
+	"uni_modules/oh-package.json5"
+]);
+const STYLE_DECL_RE = /const\s+(_style_\d+)\s*=\s*\{/g;
+const EXPORT_SFC_RE = /_export_sfc\(_sfc_main\s*,\s*\[/;
+const UNI_APP_X_STYLE_PLACEHOLDER_VERSION = "uni-app-x-style-placeholder-v2";
+function createUniAppXHarmonyApplyGeneratorSource(applyStyleSources, _applyUtilities) {
+	return applyStyleSources.join("\n");
+}
+function collectUniAppXHarmonyApplyUtilities(bundle) {
+	const utilities = /* @__PURE__ */ new Set();
+	const getBundleSource = createUniAppXBundleAssetSourceGetter(bundle);
+	for (const [file, item] of Object.entries(bundle)) {
+		if (item.type !== "chunk" || !file.endsWith(".js") || APP_JS_RE.test(file)) continue;
+		const mapSources = collectChunkMapSourcesContent(item).concat(resolveSourceMapFiles(file).flatMap((mapFile) => {
+			const source = getBundleSource(mapFile);
+			return source ? parseSourceMapSourcesContent(source) : [];
+		}));
+		for (const source of mapSources) for (const utility of collectUniAppXHarmonyApplyUtilitiesFromSources([source])) utilities.add(utility);
+	}
+	return utilities;
+}
+function collectUniAppXHarmonyApplyStyleSources(bundle) {
+	const sources = /* @__PURE__ */ new Set();
+	const getBundleSource = createUniAppXBundleAssetSourceGetter(bundle);
+	const addSource = (source) => {
+		for (const styleSource of collectUniAppXHarmonyApplyStyleSourcesFromSource(source)) sources.add(styleSource);
+	};
+	for (const [file, item] of Object.entries(bundle)) {
+		if (item.type === "asset" && file.endsWith(".uvue")) {
+			addSource(String(item.source));
+			continue;
+		}
+		if (item.type !== "chunk" || !file.endsWith(".js") || APP_JS_RE.test(file)) continue;
+		for (const sourceContent of collectChunkMapSourcesContent(item)) addSource(sourceContent);
+		for (const mapFile of resolveSourceMapFiles(file)) {
+			const source = getBundleSource(mapFile);
+			if (!source) continue;
+			for (const sourceContent of parseSourceMapSourcesContent(source)) addSource(sourceContent);
+		}
+	}
+	return [...sources];
+}
+function resolveStyleAssetFile(file) {
+	if (!UVUE_TS_RE.test(file)) return;
+	return file.replace(/\.uvue\.ts$/, ".uvue");
+}
+function resolveStylePlaceholderFallbackFiles(file) {
+	const styleAssetFile = resolveStyleAssetFile(file);
+	if (!styleAssetFile) return [];
+	const base = styleAssetFile.replace(/\.uvue$/, "");
+	return [
+		styleAssetFile,
+		`${base}.wxss`,
+		`${base}.css`
+	];
+}
+function findBalancedObjectEnd(source, start) {
+	let depth = 0;
+	let quote;
+	let escaped = false;
+	for (let index = start; index < source.length; index++) {
+		const char = source[index];
+		if (quote) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			quote = char;
+			continue;
+		}
+		if (char === "{") {
+			depth++;
+			continue;
+		}
+		if (char === "}") {
+			depth--;
+			if (depth === 0) return index + 1;
+		}
+	}
+}
+function findFirstStyleObjectDecl(source) {
+	STYLE_DECL_RE.lastIndex = 0;
+	const match = STYLE_DECL_RE.exec(source);
+	const varName = match?.[1];
+	if (!match || !varName) return;
+	const objectStart = source.indexOf("{", match.index);
+	if (objectStart < 0) return;
+	const objectEnd = findBalancedObjectEnd(source, objectStart);
+	if (!objectEnd) return;
+	return {
+		end: source[objectEnd] === ";" ? objectEnd + 1 : objectEnd,
+		objectEnd,
+		objectStart,
+		objectText: source.slice(objectStart, objectEnd),
+		start: match.index,
+		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 resolveSourceMapFiles(file) {
+	return [
+		`${file}.map`,
+		file.startsWith("assets/") ? `${file.slice(7)}.map` : void 0,
+		file.startsWith("assets/") ? void 0 : `assets/${file}.map`
+	].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 source = getBundleSource?.(cssFile);
+		return source ? cssSourceToStyleValue(source) : void 0;
+	}));
+	return mergeStyleValues(cssStyles, createStyleValueFromApplySources([...options.mapSources ?? [], ...resolveSourceMapFiles(file).flatMap((mapFile) => {
+		const source = getBundleSource?.(mapFile);
+		return source ? parseSourceMapSourcesContent(source) : [];
+	})].filter((source) => typeof source === "string"), cssStyles));
+}
+function injectStyleOption(code, styleVarName) {
+	if (code.includes("[\"styles\"")) return code;
+	const exportMatch = code.match(EXPORT_SFC_RE);
+	if (!exportMatch || exportMatch.index === void 0) return code;
+	const fileOptionIndex = code.indexOf("[\"__file\"", exportMatch.index);
+	if (fileOptionIndex < 0) return code;
+	return `${code.slice(0, fileOptionIndex)}["styles", [${styleVarName}]], ${code.slice(fileOptionIndex)}`;
+}
+function injectUniAppXStylePlaceholder(file, code, getAssetSource) {
+	const match = code.match(GEN_STYLES_PLACEHOLDER_RE);
+	const stylesName = match?.[1] ?? match?.[2];
+	if (!stylesName) return code;
+	if (!resolveStyleAssetFile(file)) return code;
+	const appStyleArray = createUtsStyleArrayFromAppStyles(code, getAssetSource?.("App.uvue.ts"));
+	if (appStyleArray) return code.replace(GEN_STYLES_PLACEHOLDER_RE, `const ${stylesName} = ${appStyleArray}`);
+	const styleSource = resolveStylePlaceholderFallbackFiles(file).map((candidate) => getAssetSource?.(candidate)).find((source) => typeof source === "string" && source.length > 0);
+	if (!styleSource) return code;
+	const styleExport = cssSourceToStyleValue(styleSource);
+	if (!styleExport) return code;
+	return code.replace(GEN_STYLES_PLACEHOLDER_RE, `const ${stylesName} = ${styleExportToUtsMap(styleExport)}`);
+}
+function injectUniAppXHarmonyGlobalStyles(file, code, getBundleSource, options = {}) {
+	if (!JS_RE.test(file) || APP_JS_RE.test(file)) return code;
+	if (options.excludeComponents && COMPONENT_JS_RE.test(file)) return code;
+	const appSource = getBundleSource?.("assets/App.js") ?? getBundleSource?.("App.js");
+	const appStyleDecl = appSource ? findFirstStyleObjectDecl(appSource) : void 0;
+	const appStyle = appStyleDecl ? parseStyleObject(appStyleDecl.objectText) : void 0;
+	const localStyleDecl = findFirstStyleObjectDecl(code);
+	const localStyle = localStyleDecl ? parseStyleObject(localStyleDecl.objectText) : void 0;
+	const styleSource = mergeStyleValues(appStyle, createStyleValueFromBundleSources(file, code, getBundleSource, options));
+	if (!styleSource) return code;
+	const mergedStyle = createMergedStyleValue(code, localStyle, styleSource);
+	if (!mergedStyle) return code;
+	const nextStyleSource = JSON.stringify(mergedStyle);
+	if (localStyleDecl) return `${code.slice(0, localStyleDecl.objectStart)}${nextStyleSource}${code.slice(localStyleDecl.objectEnd)}`;
+	const exportMatch = code.match(EXPORT_SFC_RE);
+	if (!exportMatch || exportMatch.index === void 0) return code;
+	const styleVarName = "_style_wt";
+	return injectStyleOption(`${code.slice(0, exportMatch.index)}const ${styleVarName} = ${nextStyleSource};\n${code.slice(exportMatch.index)}`, styleVarName);
+}
+function injectUniAppXHarmonyBundleStyles(bundle, options = {}) {
+	const getBundleSource = createUniAppXBundleAssetSourceGetter(bundle);
+	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,
+			mapSources: collectChunkMapSourcesContent(item)
+		});
+		if (nextSource !== currentSource) {
+			item.code = nextSource;
+			changed = true;
+		}
+	}
+	return changed;
+}
+function isUniAppXHarmonyBundle(bundle) {
+	for (const file of Object.keys(bundle)) if (HARMONY_BUNDLE_MARKER_FILES.has(file)) return true;
+	return false;
+}
+function createUniAppXBundleAssetSourceGetter(bundle) {
+	return (file) => {
+		const item = bundle[file] ?? Object.entries(bundle).find(([key, value]) => {
+			return (value.type === "asset" || value.type === "chunk") && (key === file || key.endsWith(`/${file}`));
+		})?.[1];
+		if (!item) return;
+		if (item.type === "asset") return String(item.source);
+		if (item.type === "chunk") return String(item.code);
+	};
+}
+//#endregion
 //#region src/uni-app-x/style-isolation.ts
 const manifestCache = /* @__PURE__ */ new Map();
 function resolveUniAppXStyleIsolationEnabled(root) {
@@ -58,7 +476,7 @@ function resolveUniAppXStyleIsolationEnabled(root) {
 //#region src/uni-app-x/vite.ts
 let transformUVuePromise;
 function loadTransformUVue() {
-	transformUVuePromise ?? (transformUVuePromise = import("./transform-DgCFGtQR.mjs").then((mod) => mod.transformUVue));
+	transformUVuePromise ?? (transformUVuePromise = import("./transform-DRyWUN5X.mjs").then((mod) => mod.transformUVue));
 	return transformUVuePromise;
 }
 const preprocessorLangs = new Set([
@@ -92,9 +510,21 @@ function isCssModuleExport(code) {
 function createUniAppXPlugins(options) {
 	const { appType, customAttributesEntities, disabledDefaultTemplateHandler, isIosPlatform: providedIosPlatform, mainCssChunkMatcher, runtimeState, styleHandler, generateCss, jsHandler, ensureRuntimeClassSet, getResolvedConfig, uniAppX } = options;
 	const resolvedUniAppXOptions = resolveUniAppXOptions(uniAppX);
-	const isIosPlatform = providedIosPlatform ?? resolveUniUtsPlatform().isAppIos;
+	const utsPlatform = resolveUniUtsPlatform();
+	const isIosPlatform = providedIosPlatform ?? utsPlatform.isAppIos;
+	const isHarmonyPlatform = utsPlatform.isAppHarmony;
 	const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
 	let componentLocalStyleEnabled;
+	const harmonyApplyStyleSources = /* @__PURE__ */ new Set();
+	const harmonyApplyUtilities = /* @__PURE__ */ new Set();
+	function rememberHarmonyApplySource(code) {
+		const styleSources = collectUniAppXHarmonyApplyStyleSourcesFromSource(code);
+		if (styleSources.length === 0) return;
+		for (const styleSource of styleSources) {
+			harmonyApplyStyleSources.add(styleSource);
+			for (const utility of collectUniAppXHarmonyApplyUtilitiesFromSources([styleSource])) harmonyApplyUtilities.add(utility);
+		}
+	}
 	function shouldEnableComponentLocalStyle() {
 		if (!resolvedUniAppXOptions.componentLocalStyles.enabled) {
 			componentLocalStyleEnabled = false;
@@ -109,11 +539,20 @@ function createUniAppXPlugins(options) {
 		componentLocalStyleEnabled = resolveUniAppXStyleIsolationEnabled(root);
 		return componentLocalStyleEnabled;
 	}
+	function shouldEnableHarmonyPageLocalStyle() {
+		return isHarmonyPlatform && resolvedUniAppXOptions.componentLocalStyles.enabled;
+	}
+	function isHarmonyBuildTarget() {
+		if (resolveUniUtsPlatform().isAppHarmony) return true;
+		return isUniAppXHarmonyOutDir(getResolvedConfig()?.build?.outDir);
+	}
 	async function transformStyle(code, id, query, hookContext) {
 		const parsed = query ?? parseVueRequest(id).query;
 		if (isCSSRequest(id) || parsed.vue && parsed.type === "style") {
 			if (isCssModuleExport(code)) return;
-			const generatedCss = hasTailwindSourceDirectives(code, { importFallback: true }) || hasTailwindApplyDirective(code) ? await generateCss?.(id, code, hookContext) : void 0;
+			const shouldGenerateCss = hasTailwindSourceDirectives(code, { importFallback: true }) || hasTailwindApplyDirective(code);
+			rememberHarmonyApplySource(code);
+			const generatedCss = shouldGenerateCss ? await generateCss?.(id, code, hookContext) : void 0;
 			const styleCode = typeof generatedCss === "string" && generatedCss.trim().length > 0 ? generatedCss : code;
 			const cacheKey = `${mainCssChunkMatcher(id, appType) ? "1" : "0"}:${id}`;
 			let styleHandlerOptions = cssHandlerOptionsCache.get(cacheKey);
@@ -168,19 +607,21 @@ function createUniAppXPlugins(options) {
 		},
 		async transform(code, id) {
 			if (!UVUE_NVUE_QUERY_RE.test(id)) return;
+			rememberHarmonyApplySource(code);
 			const resolvedConfig = getResolvedConfig();
 			const isServeCommand = resolvedConfig?.command === "serve";
 			const isWatchBuild = resolvedConfig?.command === "build" && !!resolvedConfig.build?.watch;
 			const isNonWatchBuild = resolvedConfig?.command === "build" && !resolvedConfig.build?.watch;
 			const currentRuntimeSet = isServeCommand || isWatchBuild || isNonWatchBuild ? await ensureRuntimeClassSet(true) : await ensureRuntimeClassSet();
 			const transformUVue = await loadTransformUVue();
-			const extraOptions = customAttributesEntities.length > 0 || disabledDefaultTemplateHandler ? {
-				customAttributesEntities,
-				disabledDefaultTemplateHandler,
-				enableComponentLocalStyle: shouldEnableComponentLocalStyle()
-			} : void 0;
-			if (extraOptions) return transformUVue(code, id, jsHandler, currentRuntimeSet, extraOptions);
-			if (shouldEnableComponentLocalStyle()) return transformUVue(code, id, jsHandler, currentRuntimeSet, { enableComponentLocalStyle: true });
+			const enableComponentLocalStyle = shouldEnableComponentLocalStyle();
+			const enablePageLocalStyle = shouldEnableHarmonyPageLocalStyle();
+			if (customAttributesEntities.length > 0 || disabledDefaultTemplateHandler || enableComponentLocalStyle || enablePageLocalStyle) return transformUVue(code, id, jsHandler, currentRuntimeSet, omitUndefined({
+				...customAttributesEntities.length > 0 ? { customAttributesEntities } : {},
+				...disabledDefaultTemplateHandler ? { disabledDefaultTemplateHandler } : {},
+				...enableComponentLocalStyle ? { enableComponentLocalStyle } : {},
+				...enablePageLocalStyle ? { enablePageLocalStyle } : {}
+			}));
 			return transformUVue(code, id, jsHandler, currentRuntimeSet);
 		},
 		async handleHotUpdate(ctx) {
@@ -195,11 +636,49 @@ function createUniAppXPlugins(options) {
 			await ensureRuntimeClassSet(true);
 		}
 	};
-	return [...cssPlugins, nvuePlugin];
+	const stylePlaceholderPlugin = {
+		name: "weapp-tailwindcss:uni-app-x:style-placeholder",
+		enforce: "post",
+		generateBundle: {
+			order: "post",
+			async handler(_options, bundle) {
+				const currentUtsPlatform = resolveUniUtsPlatform();
+				const canInferHarmonyTarget = !currentUtsPlatform.normalized || currentUtsPlatform.isApp;
+				const isHarmonyTarget = currentUtsPlatform.isAppHarmony || canInferHarmonyTarget && isHarmonyBuildTarget();
+				if (!currentUtsPlatform.isApp && !isHarmonyTarget) return;
+				const getAssetSource = createUniAppXBundleAssetSourceGetter(bundle);
+				if (isHarmonyTarget) {
+					const cssSources = [];
+					const applyStyleSources = [...harmonyApplyStyleSources, ...collectUniAppXHarmonyApplyStyleSources(bundle)];
+					const applyUtilities = new Set([...harmonyApplyUtilities, ...collectUniAppXHarmonyApplyUtilities(bundle)]);
+					if (applyStyleSources.length > 0 && applyUtilities.size > 0) {
+						const harmonyApplyCssFile = path.resolve(getResolvedConfig()?.root ?? process$1.cwd(), "uni-app-x-harmony-apply.css");
+						const generatedCss = await generateCss?.(harmonyApplyCssFile, createUniAppXHarmonyApplyGeneratorSource(applyStyleSources, applyUtilities), this);
+						if (typeof generatedCss === "string" && generatedCss.trim().length > 0) cssSources.push(generatedCss);
+					}
+					injectUniAppXHarmonyBundleStyles(bundle, {
+						cssSources,
+						excludeComponents: shouldEnableComponentLocalStyle()
+					});
+				}
+				for (const [file, item] of Object.entries(bundle)) {
+					if (item.type !== "asset" || !file.endsWith(".uvue.ts")) continue;
+					const currentSource = String(item.source);
+					const nextSource = injectUniAppXStylePlaceholder(file, currentSource, getAssetSource);
+					if (nextSource !== currentSource) item.source = nextSource;
+				}
+			}
+		}
+	};
+	return [
+		...cssPlugins,
+		nvuePlugin,
+		stylePlaceholderPlugin
+	];
 }
 function createUniAppXAssetTask(file, originalSource, outDir, options) {
 	return async () => {
-		const { cache, hashKey, createHandlerOptions, debug, jsHandler, onUpdate, runtimeSet, applyLinkedResults } = options;
+		const { cache, hashKey, createHandlerOptions, debug, getAssetSource, jsHandler, onUpdate, runtimeSet, applyLinkedResults } = options;
 		const absoluteFile = toAbsoluteOutputPath(file, outDir);
 		const rawSource = originalSource.source.toString();
 		await processCachedTask({
@@ -222,10 +701,11 @@ function createUniAppXAssetTask(file, originalSource, outDir, options) {
 						sourceType: "unambiguous"
 					}
 				}));
-				onUpdate(file, currentSource, code);
+				const nextCode = injectUniAppXStylePlaceholder(file, code, getAssetSource);
+				onUpdate(file, currentSource, nextCode);
 				debug("js handle: %s", file);
 				applyLinkedResults(linked);
-				return { result: code };
+				return { result: nextCode };
 			}
 		});
 	};
@@ -301,6 +781,163 @@ function collectLegacyContainerCompatCandidates(sourceCandidates, candidates) {
 	return new Set([...candidates, "container"]);
 }
 //#endregion
+//#region src/bundlers/vite/generate-bundle/css-output.ts
+const SOURCE_STYLE_OUTPUT_EXT_RE = /\.(?:less|sass|scss|styl|stylus|pcss|postcss)$/i;
+const CSS_SOURCE_OUTPUT_EXT_RE = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)$/i;
+const MINI_PROGRAM_STYLE_OUTPUT_EXT_RE = /\.(?:wx|ac|jx|tt|q|ty)ss$/i;
+const SOURCE_STYLE_NON_CSS_SYNTAX_RE = /(?:^|\n)\s*(?:\/\/|\$[\w-]+\s*:|@(?:use|forward|mixin|include|function)\b)/;
+function resolveReplayCssOutputFile(rootDir, file) {
+	const normalizedFile = normalizeOutputPathKey(path.isAbsolute(file) ? path.relative(rootDir, file) : file);
+	if (normalizedFile.length === 0 || normalizedFile === "." || normalizedFile === ".." || normalizedFile.startsWith("../")) return normalizeOutputPathKey(path.basename(file));
+	return normalizedFile;
+}
+function resolveViteCssOutputFile(file, opts, isWebGeneratorTarget, preserveCssExtension = false) {
+	if (isWebGeneratorTarget || preserveCssExtension || opts.cssMatcher(file) || !SOURCE_STYLE_OUTPUT_EXT_RE.test(file) || !isCSSRequest(file)) return file;
+	return file.replace(SOURCE_STYLE_OUTPUT_EXT_RE, ".wxss");
+}
+function resolveViteCssPipelineOutputFile(file, _opts, rootDir, isWebGeneratorTarget = false, preserveCssExtension = false) {
+	const normalizedFile = resolveReplayCssOutputFile(rootDir, file);
+	if (isWebGeneratorTarget || preserveCssExtension || MINI_PROGRAM_STYLE_OUTPUT_EXT_RE.test(normalizedFile) || !CSS_SOURCE_OUTPUT_EXT_RE.test(normalizedFile) || !isCSSRequest(normalizedFile)) return normalizedFile;
+	return normalizedFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, ".wxss");
+}
+function canProcessViteSourceStyleAsCss(source, file) {
+	if (SOURCE_STYLE_NON_CSS_SYNTAX_RE.test(source)) return false;
+	try {
+		postcss.parse(source, { from: file });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function normalizeCssSourceForCompare(css) {
+	return css.trim();
+}
+function stripStyleFileExtension(file) {
+	const normalized = file.replace(/[?#].*$/, "");
+	const ext = path.extname(normalized);
+	return ext ? normalized.slice(0, -ext.length) : normalized;
+}
+function isAppOriginCssFile(file) {
+	return path.basename(stripStyleFileExtension(file)) === "app-origin";
+}
+function isMainAppCssFile(file) {
+	return path.basename(stripStyleFileExtension(file)) === "app";
+}
+function isMainStyleEntryCssFile(file) {
+	const basename = path.basename(stripStyleFileExtension(file));
+	return basename === "app" || basename === "main";
+}
+function isTailwindEntryCssFile(file) {
+	return path.basename(stripStyleFileExtension(file)) === "tailwind";
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/style-matching.ts
+function isMatchingCssSourceFile(outputFile, cssSourceFile, outputRoot) {
+	return stripStyleFileExtension(path.resolve(outputRoot, outputFile)) === stripStyleFileExtension(path.resolve(cssSourceFile));
+}
+function collectStyleFileMatchBases(file, roots) {
+	const normalizedFile = file.replace(/[?#].*$/, "");
+	const bases = /* @__PURE__ */ new Set();
+	const addBase = (candidate) => {
+		const base = slash(stripStyleFileExtension(candidate));
+		if (base.length > 0) bases.add(base);
+	};
+	addBase(normalizedFile);
+	const resolvedRoots = roots.filter((root) => typeof root === "string" && root.length > 0).map((root) => path.resolve(root));
+	if (path.isAbsolute(normalizedFile)) for (const root of resolvedRoots) {
+		const relative = path.relative(root, normalizedFile);
+		if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) addBase(relative);
+	}
+	else for (const root of resolvedRoots) addBase(path.resolve(root, normalizedFile));
+	return bases;
+}
+function collectParentDirectories(file) {
+	const directories = [];
+	let current = path.dirname(path.resolve(file.replace(/[?#].*$/, "")));
+	while (true) {
+		directories.push(current);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return directories;
+}
+function hasMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) {
+	return scoreMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) > 0;
+}
+function scoreMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) {
+	const outputBases = collectStyleFileMatchBases(outputFile, [outputRoot]);
+	const sourceBases = collectStyleFileMatchBases(sourceFile, [sourceRoot, ...collectParentDirectories(sourceFile)]);
+	let bestScore = 0;
+	const hasDirectorySegment = (value) => slash(value).includes("/");
+	for (const outputBase of outputBases) for (const sourceBase of sourceBases) if (outputBase === sourceBase) bestScore = Math.max(bestScore, 1e5 + outputBase.length);
+	else if (hasDirectorySegment(sourceBase) && outputBase.endsWith(`/${sourceBase}`)) bestScore = Math.max(bestScore, 5e4 + sourceBase.length);
+	else if (hasDirectorySegment(outputBase) && sourceBase.endsWith(`/${outputBase}`)) bestScore = Math.max(bestScore, 1e3 + outputBase.length);
+	return bestScore;
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/css-config-directives.ts
+function isPackageJsonImportRequest(request) {
+	return request.startsWith("#");
+}
+function normalizeMatchedCssSourcePath(file) {
+	if (!file || !path.isAbsolute(file)) return;
+	return path.resolve(file.replace(/[?#].*$/, ""));
+}
+function collectConfiguredTailwindV4CssSources(opts) {
+	const patcherCssSources = opts.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssSources ?? [];
+	return [...opts.tailwindcss?.v4?.cssSources ?? [], ...patcherCssSources ?? []];
+}
+function collectConfiguredCssEntries(opts) {
+	const patcherCssEntries = opts.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssEntries ?? [];
+	return [
+		...opts.cssEntries ?? [],
+		...opts.tailwindcss?.v4?.cssEntries ?? [],
+		...patcherCssEntries ?? []
+	].filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+function collectCssConfigBaseCandidates(source, file, outputRoot, opts) {
+	const candidates = [];
+	const seen = /* @__PURE__ */ new Set();
+	const addCandidate = (candidate) => {
+		if (!candidate) return;
+		const normalized = path.resolve(candidate);
+		if (seen.has(normalized)) return;
+		seen.add(normalized);
+		candidates.push(normalized);
+	};
+	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 configuredCssEntries = collectConfiguredCssEntries(opts);
+	for (const cssEntry of configuredCssEntries) {
+		const resolvedCssEntry = path.resolve(cssEntry);
+		if (configuredCssEntries.length === 1 || isMatchingCssSourceFile(file, resolvedCssEntry, outputRoot) || hasMatchingStyleFileBase(file, resolvedCssEntry, outputRoot, sourceRoot)) addCandidate(path.dirname(resolvedCssEntry));
+	}
+	for (const cssSource of collectConfiguredTailwindV4CssSources(opts)) {
+		const cssSourceFile = normalizeMatchedCssSourcePath(cssSource.file);
+		const cssSourceCss = typeof cssSource.css === "string" ? normalizeCssSourceForCompare(cssSource.css) : void 0;
+		if (cssSourceFile && !isMatchingCssSourceFile(file, cssSourceFile, outputRoot) && cssSourceCss !== normalizedSource) continue;
+		addCandidate(cssSourceFile ? path.dirname(cssSourceFile) : void 0);
+		addCandidate(resolveTailwindV4CssSourceBase(cssSource, sourceBaseFallback));
+	}
+	return candidates;
+}
+function normalizeRelativeCssConfigDirectives(source, file, outputRoot, opts) {
+	if (!source.includes("@config")) return source;
+	const baseCandidates = collectCssConfigBaseCandidates(source, file, outputRoot, opts);
+	return source.replace(/@config\s+(["'])(.+?)\1\s*;?/g, (full, quote, request) => {
+		if (path.isAbsolute(request) || isPackageJsonImportRequest(request)) return full;
+		for (const base of baseCandidates) {
+			const configFile = path.resolve(base, request);
+			if (existsSync(configFile)) return `@config ${quote}${slash(configFile)}${quote};`;
+		}
+		return full;
+	});
+}
+//#endregion
 //#region src/bundlers/vite/generate-bundle/css-handler-options.ts
 function createCssHandlerOptionsCache(options) {
 	const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
@@ -481,6 +1118,169 @@ function logBundleProcessPlan(options) {
 	debug("build mode full process html=%d[%s] js=%d[%s] css=%d[%s]", processFiles.html.size, formatDebugFileList(processFiles.html), processFiles.js.size, formatDebugFileList(processFiles.js), processFiles.css.size, formatDebugFileList(processFiles.css));
 }
 //#endregion
+//#region src/bundlers/vite/generate-bundle/sfc-style-source.ts
+const SFC_STYLE_SOURCE_EXTENSIONS = [
+	".vue",
+	".uvue",
+	".nvue",
+	".svelte",
+	".mpx"
+];
+const SFC_STYLE_BLOCK_RE$1 = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+function extractSfcStyleSources(source) {
+	const styleSources = [];
+	SFC_STYLE_BLOCK_RE$1.lastIndex = 0;
+	let match = SFC_STYLE_BLOCK_RE$1.exec(source);
+	while (match !== null) {
+		styleSources.push(match[1] ?? "");
+		match = SFC_STYLE_BLOCK_RE$1.exec(source);
+	}
+	return styleSources;
+}
+function hasSfcStyleSources(source) {
+	return extractSfcStyleSources(source).length > 0;
+}
+function hasTailwindGenerationSource(source) {
+	return hasTailwindSourceDirectives(source, { importFallback: true }) || hasTailwindRootDirectives(source, { importFallback: true }) || hasTailwindApplyDirective(source);
+}
+async function resolveSfcStyleSourceFromOutputFile(outputFile, snapshot, outputRoot, sourceRoot, getSfcSource, debug) {
+	const sourceFile = resolveSfcStyleFileFromSiblingChunk(outputFile, snapshot, outputRoot, sourceRoot, debug);
+	if (!sourceFile) {
+		debug("sfc style source infer skipped: no source file for %s", outputFile);
+		return;
+	}
+	const source = getSfcSource?.(sourceFile);
+	if (source == null) {
+		debug("sfc style source infer skipped: missing known source for %s -> %s", outputFile, sourceFile);
+		return;
+	}
+	const rawSource = extractSfcStyleSources(source).join("\n");
+	if (!rawSource || !hasTailwindGenerationSource(rawSource)) {
+		debug("sfc style source infer skipped: no tailwind generation source for %s -> %s", outputFile, sourceFile);
+		return;
+	}
+	debug("sfc style source inferred: %s -> %s", outputFile, sourceFile);
+	return {
+		outputFile,
+		rawSource,
+		sourceFile
+	};
+}
+function normalizeSfcSourceFileForCompare(file) {
+	return normalizeOutputPathKey(file.replace(/[?#].*$/, ""));
+}
+function collectChunkModuleIds(output) {
+	const moduleIds = Array.isArray(output.moduleIds) ? output.moduleIds : [];
+	return [
+		output.facadeModuleId,
+		...moduleIds,
+		...Object.keys(output.modules ?? {})
+	].filter((id, index, ids) => typeof id === "string" && id.length > 0 && ids.indexOf(id) === index);
+}
+function resolveSiblingJsChunkFile(outputFile) {
+	const normalizedOutputFile = outputFile.replace(/[?#].*$/, "");
+	if (MINI_PROGRAM_STYLE_OUTPUT_EXT_RE.test(normalizedOutputFile)) return normalizedOutputFile.replace(MINI_PROGRAM_STYLE_OUTPUT_EXT_RE, ".js");
+	if (CSS_SOURCE_OUTPUT_EXT_RE.test(normalizedOutputFile)) return normalizedOutputFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, ".js");
+}
+function normalizeSfcModuleId(id) {
+	const file = id.replace(/[?#].*$/, "");
+	if (!SFC_STYLE_SOURCE_EXTENSIONS.some((extension) => file.endsWith(extension))) return;
+	if (!path.isAbsolute(file)) return;
+	return path.resolve(file);
+}
+function resolveSfcStyleFileFromSiblingChunk(outputFile, snapshot, outputRoot, sourceRoot, debug) {
+	const siblingJsFile = resolveSiblingJsChunkFile(outputFile);
+	if (!siblingJsFile) {
+		debug("sfc style sibling chunk skipped: no sibling js for %s", outputFile);
+		return;
+	}
+	const normalizedSiblingJsFile = normalizeOutputPathKey(siblingJsFile);
+	const siblingChunk = snapshot.entries.find((entry) => entry.type === "js" && entry.output.type === "chunk" && normalizeOutputPathKey(entry.file) === normalizedSiblingJsFile);
+	if (!siblingChunk || siblingChunk.output.type !== "chunk") {
+		debug("sfc style sibling chunk skipped: missing chunk for %s -> %s", outputFile, siblingJsFile);
+		return;
+	}
+	const sourceFiles = collectChunkModuleIds(siblingChunk.output).map(normalizeSfcModuleId).filter((file, index, files) => Boolean(file) && files.indexOf(file) === index);
+	if (sourceFiles.length === 0) {
+		debug("sfc style sibling chunk skipped: no sfc modules for %s -> %s", outputFile, siblingJsFile);
+		return;
+	}
+	const scoredSources = sourceFiles.map((sourceFile) => ({
+		sourceFile,
+		score: scoreMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot)
+	})).filter((item) => item.score > 0).sort((a, b) => b.score - a.score);
+	debug("sfc style sibling chunk candidates: %s -> %s %O", outputFile, siblingJsFile, scoredSources);
+	const bestScore = scoredSources[0]?.score;
+	if (!bestScore) return;
+	const bestSources = scoredSources.filter((item) => item.score === bestScore);
+	if (bestSources.length !== 1) {
+		debug("sfc style sibling chunk skipped: ambiguous best sources for %s %O", outputFile, bestSources);
+		return;
+	}
+	return bestSources[0]?.sourceFile;
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/remembered-css.ts
+function createRememberedCssRuntimeSignature(cssRuntimeSignature, cssRuntimeAffectingHash) {
+	return `${cssRuntimeSignature}:${cssRuntimeAffectingHash}`;
+}
+function findRememberedCssSources(sources, outputFile, file, originalSource, outputRoot, sourceRoot) {
+	if (!sources) return [];
+	const rememberedSources = [...sources].map(([, remembered]) => remembered);
+	const source = typeof originalSource.source === "string" ? originalSource.source : originalSource.source.toString();
+	const markerFiles = new Set(parseBundlerGeneratedCssMarkerBlocks(source).filter((block) => block.bundler === "vite" && typeof block.file === "string" && block.file.length > 0).map((block) => normalizeOutputPathKey(block.file)));
+	if (markerFiles.size > 0) {
+		const markerMatched = rememberedSources.filter((remembered) => markerFiles.has(normalizeOutputPathKey(remembered.sourceFile.replace(/[?#].*$/, ""))));
+		if (markerMatched.length > 0) return markerMatched;
+	}
+	const originalFiles = [
+		file,
+		originalSource.originalFileName,
+		...originalSource.originalFileNames ?? []
+	].filter((item) => typeof item === "string" && item.length > 0);
+	const sourceMatched = rememberedSources.filter((remembered) => originalFiles.some((originalFile) => normalizeOutputPathKey(remembered.sourceFile) === normalizeOutputPathKey(originalFile)));
+	if (sourceMatched.length > 0) return sourceMatched;
+	const outputMatched = rememberedSources.filter((remembered) => normalizeOutputPathKey(remembered.outputFile) === normalizeOutputPathKey(outputFile));
+	if (outputMatched.length > 0) return outputMatched;
+	const shouldUseRememberedApplyFallback = !hasBundlerGeneratedCssMarker(source) && !hasTailwindGenerationSource(source);
+	if (shouldUseRememberedApplyFallback && !rememberedSources.some((remembered) => hasTailwindApplyDirective(remembered.rawSource))) return [];
+	const scoredMatches = rememberedSources.filter((remembered) => !shouldUseRememberedApplyFallback || hasTailwindApplyDirective(remembered.rawSource)).filter((remembered) => !(isMainAppCssFile(outputFile) && isAppOriginCssFile(remembered.outputFile))).map((remembered) => ({
+		remembered,
+		score: Math.max(scoreMatchingStyleFileBase(outputFile, remembered.sourceFile, outputRoot, sourceRoot), scoreMatchingStyleFileBase(outputFile, remembered.outputFile, outputRoot, sourceRoot))
+	})).filter((match) => match.score > 0).sort((a, b) => b.score - a.score);
+	const bestScore = scoredMatches[0]?.score;
+	return bestScore ? scoredMatches.filter((match) => match.score === bestScore).map((match) => match.remembered) : [];
+}
+function mergeRememberedCssSources(sources, outputFile) {
+	if (sources.length <= 1) return sources[0];
+	const seen = /* @__PURE__ */ new Set();
+	const rawSources = [];
+	for (const source of sources) {
+		const key = `${source.sourceFile}\0${source.rawSource}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		rawSources.push(source.rawSource);
+	}
+	return {
+		outputFile,
+		rawSource: rawSources.join("\n"),
+		sourceFile: sources[0]?.sourceFile ?? outputFile
+	};
+}
+function collectRememberedCssReplayGroups(sources, opts, rootDir, isWebGeneratorTarget, preserveCssExtension) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const [key, remembered] of sources ?? []) {
+		const outputKey = normalizeOutputPathKey(resolveViteCssPipelineOutputFile(remembered.outputFile, opts, rootDir, isWebGeneratorTarget, preserveCssExtension));
+		const group = groups.get(outputKey) ?? [];
+		group.push({
+			key,
+			remembered
+		});
+		groups.set(outputKey, group);
+	}
+	return groups;
+}
+//#endregion
 //#region src/bundlers/vite/generate-bundle/rollup-assets.ts
 function createReplayCssAsset(fileName, source) {
 	return {
@@ -559,6 +1359,75 @@ function hasRuntimeAffectingSourceChanges(changedByType) {
 	return changedByType.html.size > 0 || changedByType.js.size > 0;
 }
 //#endregion
+//#region src/bundlers/vite/generate-bundle/subpackages.ts
+function readBundleAssetSource(output) {
+	if (output.type !== "asset") return;
+	return typeof output.source === "string" ? output.source : output.source.toString();
+}
+function normalizePackageRoot(root) {
+	return normalizeOutputPathKey(root).replace(/\/+$/, "");
+}
+function collectMiniProgramSubpackageRoots(bundle) {
+	let hasAppJson = false;
+	const roots = /* @__PURE__ */ new Set();
+	for (const [file, output] of Object.entries(bundle)) {
+		const outputFile = output.fileName || file;
+		if (path.basename(outputFile) !== "app.json") continue;
+		const source = readBundleAssetSource(output);
+		if (!source) continue;
+		hasAppJson = true;
+		try {
+			const appJson = JSON.parse(source);
+			const subPackages = Array.isArray(appJson.subPackages) ? appJson.subPackages : Array.isArray(appJson.subpackages) ? appJson.subpackages : [];
+			for (const subPackage of subPackages) {
+				if (typeof subPackage.root !== "string" || subPackage.root.length === 0) continue;
+				roots.add(normalizePackageRoot(subPackage.root));
+			}
+		} catch {}
+	}
+	return hasAppJson ? roots : void 0;
+}
+function isSubpackageOutputFile(file, subpackageRoots) {
+	const normalizedFile = normalizeOutputPathKey(file.replace(/[?#].*$/, ""));
+	for (const root of subpackageRoots) if (root.length > 0 && (normalizedFile === root || normalizedFile.startsWith(`${root}/`) || normalizedFile.endsWith(`/${root}`) || normalizedFile.includes(`/${root}/`))) return true;
+	return false;
+}
+function resolveSubpackageSourceRootFromModuleId(moduleId, subpackageRoot) {
+	const file = slash(path.resolve(moduleId.replace(/[?#].*$/, "")));
+	const normalizedRoot = normalizePackageRoot(subpackageRoot);
+	const rootSegment = `/${normalizedRoot}/`;
+	const rootIndex = file.lastIndexOf(rootSegment);
+	if (rootIndex >= 0) return file.slice(0, rootIndex + rootSegment.length - 1);
+	const rootSuffix = `/${normalizedRoot}`;
+	if (file.endsWith(rootSuffix)) return file;
+}
+function collectMiniProgramSubpackageSourceEntries(snapshot, subpackageRoots, sourceBaseRoots) {
+	const sourceRoots = /* @__PURE__ */ new Set();
+	const sourceEntries = [];
+	for (const entry of snapshot.entries) {
+		if (entry.output.type !== "chunk" || !isSubpackageOutputFile(entry.file, subpackageRoots)) continue;
+		const matchedSubpackageRoot = [...subpackageRoots].find((root) => isSubpackageOutputFile(entry.file, new Set([root])));
+		if (!matchedSubpackageRoot) continue;
+		for (const moduleId of collectChunkModuleIds(entry.output)) {
+			if (!path.isAbsolute(moduleId.replace(/[?#].*$/, ""))) continue;
+			const sourceRoot = resolveSubpackageSourceRootFromModuleId(moduleId, matchedSubpackageRoot);
+			if (sourceRoot) sourceRoots.add(sourceRoot);
+		}
+	}
+	sourceEntries.push(...[...sourceRoots].map((sourceRoot) => ({
+		base: sourceRoot,
+		negated: false,
+		pattern: "**/*"
+	})));
+	const resolvedBaseRoots = sourceBaseRoots.filter((baseRoot) => typeof baseRoot === "string" && baseRoot.length > 0).map((baseRoot) => path.resolve(baseRoot)).filter((baseRoot, index, roots) => roots.indexOf(baseRoot) === index);
+	for (const baseRoot of resolvedBaseRoots) for (const subpackageRoot of subpackageRoots) sourceEntries.push({
+		base: baseRoot,
+		negated: false,
+		pattern: `**/${normalizePackageRoot(subpackageRoot)}/**`
+	});
+	return sourceEntries;
+}
+//#endregion
 //#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
 let _lazyMatch = () => {
 	var __lib__ = (() => {
@@ -1005,11 +1874,372 @@ const mix = (del = delimiter) => {
 const posix = /* @__PURE__ */ mix(":");
 const win32 = /* @__PURE__ */ mix(";");
 //#endregion
+//#region src/bundlers/vite/processed-css-assets/css-rules.ts
+const MINI_PROGRAM_PREFLIGHT_SELECTOR_KEY = "view,text,::after,::before";
+const MINI_PROGRAM_PREFLIGHT_SELECTOR_KEYS = new Set([
+	"view",
+	"text",
+	"::after",
+	"::before"
+]);
+const MINI_PROGRAM_THEME_SCOPE_SELECTOR_KEY = ":host,page,.tw-root,wx-root-portal-content";
+const MINI_PROGRAM_THEME_SCOPE_SELECTOR_KEYS = new Set([
+	":host",
+	"page",
+	".tw-root",
+	"wx-root-portal-content"
+]);
+function normalizeCssForContainment(css) {
+	return css.replace(/\/\*[\s\S]*?\*\//g, "").replace(/::(before|after)\b/g, ":$1").replace(/\s+/g, " ").replace(/\s*([{}:;,>+~()])\s*/g, "$1").replace(/;\}/g, "}").trim();
+}
+function collectNormalizedCssNodes(css) {
+	try {
+		return (postcss.parse(css).nodes ?? []).filter((node) => node.type !== "comment").map((node) => normalizeCssForContainment(node.toString())).filter(Boolean);
+	} catch {
+		const normalizedCss = normalizeCssForContainment(css);
+		return normalizedCss ? [normalizedCss] : [];
+	}
+}
+function normalizeCssRuleKeyPart(value) {
+	return value.replace(/::(before|after)\b/g, ":$1").replace(/\s+/g, " ").replace(/\s*([>+~(),])\s*/g, "$1").trim();
+}
+function getRuleAtRuleChain(rule) {
+	const chain = [];
+	let parent = rule.parent;
+	while (parent && parent.type !== "root") {
+		if (parent.type === "atrule") chain.unshift(`@${parent.name} ${normalizeCssRuleKeyPart(parent.params)}`);
+		parent = parent.parent;
+	}
+	return chain;
+}
+function getCssRuleStructuralKey(rule) {
+	const selector = normalizeCssRuleKeyPart(rule.selector);
+	if (selector.length === 0) return;
+	return [...getRuleAtRuleChain(rule), selector].join("|");
+}
+function getCssRuleStructuralKeyWithSelectorKey(rule, selectorKey) {
+	return [...getRuleAtRuleChain(rule), selectorKey].join("|");
+}
+function getCssRuleContentKey(rule) {
+	const structuralKey = getCssRuleStructuralKey(rule);
+	if (!structuralKey) return;
+	return [structuralKey, normalizeCssForContainment(rule.toString())].join("|");
+}
+function collectCssRuleContentKeys(css) {
+	const keys = /* @__PURE__ */ new Set();
+	try {
+		postcss.parse(css).walkRules((rule) => {
+			const key = getCssRuleContentKey(rule);
+			if (key) keys.add(key);
+		});
+	} catch {}
+	return keys;
+}
+function normalizeCssDeclarationKey(decl) {
+	return [
+		decl.prop.trim(),
+		normalizeCssForContainment(decl.value),
+		decl.important ? "!important" : ""
+	].join(":");
+}
+function collectCssRuleDeclarationKeys(rule) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const node of rule.nodes ?? []) if (node.type === "decl") keys.add(normalizeCssDeclarationKey(node));
+	return keys;
+}
+function collectCssRuleDeclarationProps(rule) {
+	const props = /* @__PURE__ */ new Set();
+	for (const node of rule.nodes ?? []) if (node.type === "decl") props.add(node.prop.trim());
+	return props;
+}
+function collectCssRuleDeclarations(rule) {
+	return (rule.nodes ?? []).filter((node) => node.type === "decl");
+}
+function collectCssRuleDeclarationKeyMap(css) {
+	const map = /* @__PURE__ */ new Map();
+	try {
+		postcss.parse(css).walkRules((rule) => {
+			const key = getCssRuleStructuralKey(rule);
+			if (!key) return;
+			const declarations = collectCssRuleDeclarationKeys(rule);
+			if (declarations.size === 0) return;
+			let existing = map.get(key);
+			if (!existing) {
+				existing = /* @__PURE__ */ new Set();
+				map.set(key, existing);
+			}
+			for (const declaration of declarations) existing.add(declaration);
+		});
+	} catch {}
+	return map;
+}
+function collectCssRuleDeclarationRecords(root, resolveRuleKey = getCssRuleStructuralKey) {
+	const map = /* @__PURE__ */ new Map();
+	root.walkRules((rule) => {
+		const key = resolveRuleKey(rule);
+		if (!key) return;
+		const keys = collectCssRuleDeclarationKeys(rule);
+		if (keys.size === 0) return;
+		const records = map.get(key) ?? [];
+		records.push({
+			rule,
+			keys,
+			props: collectCssRuleDeclarationProps(rule)
+		});
+		map.set(key, records);
+	});
+	return map;
+}
+function normalizeSimpleMiniProgramSelectorNode(node) {
+	if (node.type === "tag") {
+		const value = node.value.toLowerCase();
+		if (value === "view" || value === "text" || value === "page" || value === "wx-root-portal-content") return value;
+		return;
+	}
+	if (node.type === "class") return node.value.toLowerCase() === "tw-root" ? ".tw-root" : void 0;
+	if (node.type === "pseudo") {
+		if (node.nodes && node.nodes.length > 0) return;
+		const value = node.value.toLowerCase();
+		if (value === ":before" || value === "::before") return "::before";
+		if (value === ":after" || value === "::after") return "::after";
+		if (value === ":host") return ":host";
+	}
+}
+function normalizeSimpleMiniProgramSelector(selector) {
+	if (selector.nodes.length !== 1) return;
+	return normalizeSimpleMiniProgramSelectorNode(selector.nodes[0]);
+}
+function collectMiniProgramSelectorSet(selector) {
+	try {
+		const selectorSet = /* @__PURE__ */ new Set();
+		const ast = selectorParser().astSync(selector);
+		for (const child of ast.nodes) {
+			const key = normalizeSimpleMiniProgramSelector(child);
+			if (!key || selectorSet.has(key)) return;
+			selectorSet.add(key);
+		}
+		return selectorSet;
+	} catch {
+		return;
+	}
+}
+function isSameSelectorSet(actual, expected) {
+	return actual?.size === expected.size && [...expected].every((key) => actual.has(key));
+}
+function getMiniProgramPreflightRuleStructuralKey(rule) {
+	if (!isSameSelectorSet(collectMiniProgramSelectorSet(rule.selector), MINI_PROGRAM_PREFLIGHT_SELECTOR_KEYS)) return;
+	return getCssRuleStructuralKeyWithSelectorKey(rule, MINI_PROGRAM_PREFLIGHT_SELECTOR_KEY);
+}
+function getMiniProgramThemeScopeRuleStructuralKey(rule) {
+	if (!isSameSelectorSet(collectMiniProgramSelectorSet(rule.selector), MINI_PROGRAM_THEME_SCOPE_SELECTOR_KEYS)) return;
+	return getCssRuleStructuralKeyWithSelectorKey(rule, MINI_PROGRAM_THEME_SCOPE_SELECTOR_KEY);
+}
+function mergeMiniProgramPreflightRuleDeclarations(baseCss, css) {
+	try {
+		const baseRoot = postcss.parse(baseCss);
+		const root = postcss.parse(css);
+		const baseRuleRecords = collectCssRuleDeclarationRecords(baseRoot, getMiniProgramPreflightRuleStructuralKey);
+		let changedBase = false;
+		let changedCss = false;
+		root.walkRules((rule) => {
+			const key = getMiniProgramPreflightRuleStructuralKey(rule);
+			if (!key) return;
+			const records = baseRuleRecords.get(key);
+			const targetRecord = records?.[0];
+			if (!targetRecord) return;
+			const existingProps = new Set(records.flatMap((record) => [...record.props]));
+			for (const decl of collectCssRuleDeclarations(rule)) {
+				const prop = decl.prop.trim();
+				if (existingProps.has(prop)) continue;
+				targetRecord.rule.append(decl.clone());
+				targetRecord.keys.add(normalizeCssDeclarationKey(decl));
+				targetRecord.props.add(prop);
+				existingProps.add(prop);
+				changedBase = true;
+			}
+			rule.remove();
+			changedCss = true;
+		});
+		if (!changedBase && !changedCss) return {
+			baseCss,
+			css,
+			changed: false
+		};
+		removeEmptyAtRules(root);
+		return {
+			baseCss: changedBase ? baseRoot.toString() : baseCss,
+			css: changedCss ? root.toString().trim() : css,
+			changed: true
+		};
+	} catch {
+		return {
+			baseCss,
+			css,
+			changed: false
+		};
+	}
+}
+function mergeMiniProgramThemeScopeRuleDeclarations(baseCss, css) {
+	try {
+		const baseRoot = postcss.parse(baseCss);
+		const root = postcss.parse(css);
+		const baseRuleRecords = collectCssRuleDeclarationRecords(baseRoot, getMiniProgramThemeScopeRuleStructuralKey);
+		let changedBase = false;
+		let changedCss = false;
+		root.walkRules((rule) => {
+			const key = getMiniProgramThemeScopeRuleStructuralKey(rule);
+			if (!key) return;
+			const records = baseRuleRecords.get(key);
+			const targetRecord = records?.[0];
+			if (!targetRecord) return;
+			const incomingDeclarations = collectCssRuleDeclarations(rule);
+			if (incomingDeclarations.length === 0) return;
+			const existingKeys = new Set(records.flatMap((record) => [...record.keys]));
+			const existingProps = new Set(records.flatMap((record) => [...record.props]));
+			if (incomingDeclarations.some((decl) => {
+				const prop = decl.prop.trim();
+				return existingProps.has(prop) && !existingKeys.has(normalizeCssDeclarationKey(decl));
+			})) return;
+			for (const decl of incomingDeclarations) {
+				const declarationKey = normalizeCssDeclarationKey(decl);
+				if (existingKeys.has(declarationKey)) continue;
+				targetRecord.rule.append(decl.clone());
+				targetRecord.keys.add(declarationKey);
+				targetRecord.props.add(decl.prop.trim());
+				existingKeys.add(declarationKey);
+				existingProps.add(decl.prop.trim());
+				changedBase = true;
+			}
+			rule.remove();
+			changedCss = true;
+		});
+		if (!changedBase && !changedCss) return {
+			baseCss,
+			css,
+			changed: false
+		};
+		removeEmptyAtRules(root);
+		return {
+			baseCss: changedBase ? baseRoot.toString() : baseCss,
+			css: changedCss ? root.toString().trim() : css,
+			changed: true
+		};
+	} catch {
+		return {
+			baseCss,
+			css,
+			changed: false
+		};
+	}
+}
+function isCssRuleCoveredByDeclarations(rule, baseRuleDeclarationKeys) {
+	const key = getCssRuleStructuralKey(rule);
+	if (!key) return false;
+	const baseDeclarations = baseRuleDeclarationKeys.get(key);
+	if (!baseDeclarations) return false;
+	const declarations = collectCssRuleDeclarationKeys(rule);
+	return declarations.size > 0 && [...declarations].every((declaration) => baseDeclarations.has(declaration));
+}
+function mergeCoveredCssRuleDeclarations(baseCss, css) {
+	try {
+		const baseRoot = postcss.parse(baseCss);
+		const root = postcss.parse(css);
+		const baseRuleRecords = collectCssRuleDeclarationRecords(baseRoot);
+		let changedBase = false;
+		let changedCss = false;
+		root.walkRules((rule) => {
+			const key = getCssRuleStructuralKey(rule);
+			const records = key ? baseRuleRecords.get(key) : void 0;
+			if (!records || records.length === 0) return;
+			const incomingDeclarations = collectCssRuleDeclarations(rule);
+			if (incomingDeclarations.length === 0) return;
+			const baseKeys = new Set(records.flatMap((record) => [...record.keys]));
+			if (incomingDeclarations.filter((decl) => baseKeys.has(normalizeCssDeclarationKey(decl))).length === 0) return;
+			const missingDeclarations = incomingDeclarations.filter((decl) => !baseKeys.has(normalizeCssDeclarationKey(decl)));
+			if (missingDeclarations.length === 0) {
+				rule.remove();
+				changedCss = true;
+				return;
+			}
+			const baseProps = new Set(records.flatMap((record) => [...record.props]));
+			if (missingDeclarations.filter((decl) => baseProps.has(decl.prop.trim())).length > 0) return;
+			const targetRecord = records[0];
+			if (!targetRecord) return;
+			for (const decl of missingDeclarations) {
+				targetRecord.rule.append(decl.clone());
+				targetRecord.keys.add(normalizeCssDeclarationKey(decl));
+				targetRecord.props.add(decl.prop.trim());
+			}
+			rule.remove();
+			changedBase = true;
+			changedCss = true;
+		});
+		if (!changedBase && !changedCss) return {
+			baseCss,
+			css,
+			changed: false
+		};
+		removeEmptyAtRules(root);
+		return {
+			baseCss: changedBase ? baseRoot.toString() : baseCss,
+			css: changedCss ? root.toString().trim() : css,
+			changed: true
+		};
+	} catch {
+		return {
+			baseCss,
+			css,
+			changed: false
+		};
+	}
+}
+function removeEmptyAtRules(root) {
+	root.walkAtRules((atRule) => {
+		if (atRule.nodes && atRule.nodes.every((node) => node.type === "comment")) atRule.remove();
+	});
+}
+function filterExistingCssRules(baseCss, css) {
+	const baseRuleKeys = collectCssRuleContentKeys(baseCss);
+	if (baseRuleKeys.size === 0) return css;
+	try {
+		const root = postcss.parse(css);
+		const baseRuleDeclarationKeys = collectCssRuleDeclarationKeyMap(baseCss);
+		let changed = false;
+		root.walkRules((rule) => {
+			const key = getCssRuleContentKey(rule);
+			if (key && baseRuleKeys.has(key) || isCssRuleCoveredByDeclarations(rule, baseRuleDeclarationKeys)) {
+				rule.remove();
+				changed = true;
+			}
+		});
+		if (!changed) return css;
+		removeEmptyAtRules(root);
+		return root.toString().trim();
+	} catch {
+		return css;
+	}
+}
+function containsCssAfterMinify(baseCss, css) {
+	if (baseCss.includes(css)) return true;
+	const normalizedBaseCss = normalizeCssForContainment(baseCss);
+	const normalizedCss = normalizeCssForContainment(css);
+	if (normalizedCss.length > 0 && normalizedBaseCss.includes(normalizedCss)) return true;
+	const normalizedNodes = collectNormalizedCssNodes(css);
+	if (normalizedNodes.length > 0 && normalizedNodes.every((node) => normalizedBaseCss.includes(node))) return true;
+	const baseRuleKeys = collectCssRuleContentKeys(baseCss);
+	const ruleKeys = collectCssRuleContentKeys(css);
+	return ruleKeys.size > 0 && [...ruleKeys].every((key) => baseRuleKeys.has(key));
+}
+//#endregion
 //#region src/bundlers/vite/processed-css-assets.ts
 const CSS_OUTPUT_FILE_RE = /\.(?:css|wxss|acss|ttss|qss|jxss|tyss)(?:$|[?#])/i;
 function isCssOutputFile(file) {
 	return CSS_OUTPUT_FILE_RE.test(file);
 }
+function isMainStyleAssetFile(file) {
+	const basename = normalizeOutputPathKey(file.replace(/[?#].*$/, "")).replace(/\.(?:css|wxss|acss|ttss|qss|jxss|tyss)$/i, "").split("/").pop();
+	return basename === "app" || basename === "main";
+}
 function getAssetFile(bundleFile, asset) {
 	return asset.fileName || bundleFile;
 }
@@ -1082,6 +2312,9 @@ function resolveViteProcessedCssAssetSource(file, rawSource, resolveViteProcesse
 	const matchedCss = blocks.filter((block) => isMatchingGeneratedCssMarkerFile(file, block.file, resolveViteProcessedCssOutputFile)).map((block) => block.css);
 	return matchedCss.length > 0 ? matchedCss.join("\n") : stripBundlerGeneratedCssMarkers(rawSource);
 }
+function collectMatchingGeneratedCssMarkerFiles(file, rawSource, resolveViteProcessedCssOutputFile) {
+	return parseBundlerGeneratedCssMarkerBlocks(rawSource).filter((block) => block.bundler === "vite").filter((block) => isMatchingGeneratedCssMarkerFile(file, block.file, resolveViteProcessedCssOutputFile)).map((block) => block.file).filter((markerFile) => typeof markerFile === "string" && markerFile.length > 0);
+}
 function shouldInjectViteProcessedCssResult(opts, targetFile, sourceFile, options) {
 	if (options.injectIntoMain === true) return true;
 	if (options.injectIntoMain === false) return false;
@@ -1090,6 +2323,28 @@ function shouldInjectViteProcessedCssResult(opts, targetFile, sourceFile, option
 	const sourceBaseName = sourceFileKey.replace(/\.(?:css|wxss|acss|ttss|qss|jxss|tyss)$/i, "").split("/").pop();
 	return sourceFileKey !== targetFileKey && (opts.mainCssChunkMatcher(sourceFile, opts.appType) || sourceBaseName === "app" || sourceBaseName === "main");
 }
+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))));
+}
+function removeCssCoveredByImportedViteResults(css, importedCssSources) {
+	if (importedCssSources.length === 0) return css;
+	const importedCss = importedCssSources.map((source) => stripBundlerGeneratedCssMarkers(source).trim()).filter(Boolean).join("\n");
+	if (importedCss.length === 0) return css;
+	return filterExistingCssRules(importedCss, css);
+}
+function collectImportedBundleCssSources(bundle, importedStyleFiles) {
+	if (importedStyleFiles.size === 0) return [];
+	const importedFileNames = new Set([...importedStyleFiles].map((file) => posix.posix.basename(file)));
+	const importedSources = [];
+	for (const [bundleFile, output] of Object.entries(bundle)) {
+		if (output.type !== "asset") continue;
+		const file = normalizeOutputPathKey(getAssetFile(bundleFile, output));
+		if (!(importedStyleFiles.has(file) || !file.includes("/") && importedFileNames.has(posix.posix.basename(file)))) continue;
+		importedSources.push(readAssetSource(output));
+	}
+	return importedSources;
+}
 function collectViteProcessedCssAssetResults(bundle, options) {
 	let collected = 0;
 	for (const [bundleFile, output] of Object.entries(bundle)) {
@@ -1102,8 +2357,18 @@ function collectViteProcessedCssAssetResults(bundle, options) {
 		options.markCssAssetProcessed?.(output, file);
 		options.recordCssAssetResult?.(file, nextCss);
 		const resolvedOutputFile = options.resolveViteProcessedCssOutputFile?.(file) ?? file;
-		const shouldReplayIntoMainCss = options.opts != null && normalizeOutputPathKey(resolvedOutputFile) !== normalizeOutputPathKey(file) && options.opts.mainCssChunkMatcher(resolvedOutputFile, options.opts.appType);
-		options.recordViteProcessedCssAssetResult?.(file, nextCss, { injectIntoMain: shouldReplayIntoMainCss || void 0 });
+		const shouldReplayIntoMainCss = options.opts != null && isMainStyleAssetFile(file) && (normalizeOutputPathKey(resolvedOutputFile) !== normalizeOutputPathKey(file) || !options.opts.mainCssChunkMatcher(file, options.opts.appType));
+		options.recordViteProcessedCssAssetResult?.(file, nextCss, {
+			injectIntoMain: shouldReplayIntoMainCss || void 0,
+			outputFile: resolvedOutputFile
+		});
+		for (const markerFile of collectMatchingGeneratedCssMarkerFiles(file, rawSource, options.resolveViteProcessedCssOutputFile)) {
+			if (normalizeOutputPathKey(markerFile) === normalizeOutputPathKey(file)) continue;
+			options.recordViteProcessedCssAssetResult?.(markerFile, nextCss, {
+				injectIntoMain: shouldReplayIntoMainCss || void 0,
+				outputFile: resolvedOutputFile
+			});
+		}
 		options.debug?.("collect vite-processed css asset: %s bytes=%d", file, nextCss.length);
 		collected++;
 	}
@@ -1118,10 +2383,10 @@ function injectViteProcessedCssIntoMainCssAssets(bundle, options) {
 		} : {
 			file,
 			css: record.css,
-			injectIntoMain: record.injectIntoMain
+			injectIntoMain: record.injectIntoMain,
+			outputFile: record.outputFile
 		};
 	}).filter((record) => record.css.length > 0);
-	if (viteCssResults.length === 0) return 0;
 	let injected = 0;
 	for (const [bundleFile, output] of Object.entries(bundle)) {
 		if (output.type !== "asset") continue;
@@ -1131,18 +2396,45 @@ function injectViteProcessedCssIntoMainCssAssets(bundle, options) {
 		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));
 		for (const record of viteCssResults) {
 			if (!shouldInjectViteProcessedCssResult(options.opts, mainFileKey, record.file, record)) continue;
-			if (importedStyleFiles.has(normalizeOutputPathKey(record.file))) continue;
-			const css = stripBundlerGeneratedCssMarkers(record.css).trim();
+			if (isViteProcessedCssResultImported(record, importedStyleFiles)) continue;
+			let css = stripBundlerGeneratedCssMarkers(record.css).trim();
+			css = removeCssCoveredByImportedViteResults(css, importedCssSources).trim();
 			if (css.length === 0) continue;
 			const mergedLayerCss = mergeMarkedUserLayerComponentsCss(nextCss, css);
 			if (mergedLayerCss.merged) {
 				nextCss = mergedLayerCss.css;
-				continue;
+				css = extractMarkedUserLayerComponentsCss(css).rest.trim();
+				if (css.length === 0) continue;
+			}
+			if (containsCssAfterMinify(nextCss, css)) continue;
+			const mergedPreflightDeclarations = mergeMiniProgramPreflightRuleDeclarations(nextCss, css);
+			if (mergedPreflightDeclarations.changed) {
+				nextCss = mergedPreflightDeclarations.baseCss;
+				css = mergedPreflightDeclarations.css.trim();
+				if (css.length === 0) continue;
+			}
+			const mergedThemeScopeDeclarations = mergeMiniProgramThemeScopeRuleDeclarations(nextCss, css);
+			if (mergedThemeScopeDeclarations.changed) {
+				nextCss = mergedThemeScopeDeclarations.baseCss;
+				css = mergedThemeScopeDeclarations.css.trim();
+				if (css.length === 0) continue;
+			}
+			const mergedRuleDeclarations = mergeCoveredCssRuleDeclarations(nextCss, css);
+			if (mergedRuleDeclarations.changed) {
+				nextCss = mergedRuleDeclarations.baseCss;
+				css = mergedRuleDeclarations.css.trim();
+				if (css.length === 0) continue;
 			}
-			if (nextCss.includes(css)) continue;
-			nextCss = appendCss(nextCss, css);
+			const missingCss = filterExistingCssRules(nextCss, css);
+			if (missingCss.length === 0 || containsCssAfterMinify(nextCss, missingCss)) continue;
+			nextCss = appendCss(nextCss, missingCss);
 		}
 		if (nextCss === originalSource) continue;
 		output.source = nextCss;
@@ -1151,81 +2443,30 @@ function injectViteProcessedCssIntoMainCssAssets(bundle, options) {
 		options.onUpdate?.(file, originalSource, nextCss);
 		options.debug?.("inject vite-processed css into main css asset: %s bytes=%d", file, nextCss.length);
 		injected++;
-	}
-	return injected;
-}
-//#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 {};
-	return {
-		uniAppX: true,
-		uniAppXCssTarget: "uvue",
-		uniAppXUnsupported: resolveUniAppXOptions(opts.uniAppX).uvueUnsupported
-	};
-}
-//#endregion
-//#region src/bundlers/vite/generate-bundle.ts
-function addSiblingCssFile(files, file) {
-	if (file.endsWith(".wxml")) files.add(file.replace(/\.wxml$/, ".wxss"));
-	else if (file.endsWith(".js")) files.add(file.replace(/\.js$/, ".wxss"));
-}
-function collectRuntimeLinkedCssFiles(snapshot) {
-	const files = /* @__PURE__ */ new Set();
-	for (const file of snapshot.runtimeAffectingChangedByType.html) addSiblingCssFile(files, file);
-	for (const file of snapshot.runtimeAffectingChangedByType.js) addSiblingCssFile(files, file);
-	return files;
-}
-function resolveReplayCssOutputFile(rootDir, file) {
-	const normalizedFile = normalizeOutputPathKey(path.isAbsolute(file) ? path.relative(rootDir, file) : file);
-	if (normalizedFile.length === 0 || normalizedFile === "." || normalizedFile === ".." || normalizedFile.startsWith("../")) return normalizeOutputPathKey(path.basename(file));
-	return normalizedFile;
-}
-const SOURCE_STYLE_OUTPUT_EXT_RE = /\.(?:less|sass|scss|styl|stylus|pcss|postcss)$/i;
-const CSS_SOURCE_OUTPUT_EXT_RE = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)$/i;
-const MINI_PROGRAM_STYLE_OUTPUT_EXT_RE = /\.(?:wx|ac|jx|tt|q|ty)ss$/i;
-const SOURCE_STYLE_NON_CSS_SYNTAX_RE = /(?:^|\n)\s*(?:\/\/|\$[\w-]+\s*:|@(?:use|forward|mixin|include|function)\b)/;
-function resolveViteCssOutputFile(file, opts, isWebGeneratorTarget) {
-	if (isWebGeneratorTarget || opts.cssMatcher(file) || !SOURCE_STYLE_OUTPUT_EXT_RE.test(file) || !isCSSRequest(file)) return file;
-	return file.replace(SOURCE_STYLE_OUTPUT_EXT_RE, ".wxss");
-}
-function resolveViteCssPipelineOutputFile(file, _opts, rootDir, isWebGeneratorTarget = false, preserveCssExtension = false) {
-	const normalizedFile = resolveReplayCssOutputFile(rootDir, file);
-	if (isWebGeneratorTarget || preserveCssExtension || MINI_PROGRAM_STYLE_OUTPUT_EXT_RE.test(normalizedFile) || !CSS_SOURCE_OUTPUT_EXT_RE.test(normalizedFile) || !isCSSRequest(normalizedFile)) return normalizedFile;
-	return normalizedFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, ".wxss");
-}
-function canProcessViteSourceStyleAsCss(source, file) {
-	if (SOURCE_STYLE_NON_CSS_SYNTAX_RE.test(source)) return false;
-	try {
-		postcss.parse(source, { from: file });
-		return true;
-	} catch {
-		return false;
-	}
-}
-function isPackageJsonImportRequest(request) {
-	return request.startsWith("#");
-}
-function normalizeMatchedCssSourcePath(file) {
-	if (!file || !path.isAbsolute(file)) return;
-	return path.resolve(file.replace(/[?#].*$/, ""));
-}
-function stripStyleFileExtension(file) {
-	const normalized = file.replace(/[?#].*$/, "");
-	const ext = path.extname(normalized);
-	return ext ? normalized.slice(0, -ext.length) : normalized;
-}
-function isAppOriginCssFile(file) {
-	return path.basename(stripStyleFileExtension(file)) === "app-origin";
+	}
+	return injected;
 }
-function isMainAppCssFile(file) {
-	return path.basename(stripStyleFileExtension(file)) === "app";
+//#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 {};
+	return {
+		uniAppX: true,
+		uniAppXCssTarget: "uvue",
+		uniAppXUnsupported: resolveUniAppXOptions(opts.uniAppX).uvueUnsupported
+	};
 }
-function normalizeCssSourceForCompare(css) {
-	return css.trim();
+//#endregion
+//#region src/bundlers/vite/generate-bundle.ts
+function addSiblingCssFile(files, file) {
+	if (file.endsWith(".wxml")) files.add(file.replace(/\.wxml$/, ".wxss"));
+	else if (file.endsWith(".js")) files.add(file.replace(/\.js$/, ".wxss"));
 }
-function createRememberedCssRuntimeSignature(cssRuntimeSignature, cssRuntimeAffectingHash) {
-	return `${cssRuntimeSignature}:${cssRuntimeAffectingHash}`;
+function collectRuntimeLinkedCssFiles(snapshot) {
+	const files = /* @__PURE__ */ new Set();
+	for (const file of snapshot.runtimeAffectingChangedByType.html) addSiblingCssFile(files, file);
+	for (const file of snapshot.runtimeAffectingChangedByType.js) addSiblingCssFile(files, file);
+	return files;
 }
 async function createScopedGeneratorCandidateSignature(rawSource, sourceFile, fallbackSignature, getSourceCandidatesForEntries, options = {}) {
 	if (!getSourceCandidatesForEntries || !rawSource.includes("@source")) return fallbackSignature;
@@ -1234,124 +2475,11 @@ async function createScopedGeneratorCandidateSignature(rawSource, sourceFile, fa
 	const scopedSignature = createCandidateSignature(getSourceCandidatesForEntries(resolved.entries));
 	return options.includeFallbackSignature === true ? `${scopedSignature}:${fallbackSignature}` : scopedSignature;
 }
-function isMatchingCssSourceFile(outputFile, cssSourceFile, outputRoot) {
-	return stripStyleFileExtension(path.resolve(outputRoot, outputFile)) === stripStyleFileExtension(path.resolve(cssSourceFile));
-}
-function collectStyleFileMatchBases(file, roots) {
-	const normalizedFile = file.replace(/[?#].*$/, "");
-	const bases = /* @__PURE__ */ new Set();
-	const addBase = (candidate) => {
-		const base = slash(stripStyleFileExtension(candidate));
-		if (base.length > 0) bases.add(base);
-	};
-	addBase(normalizedFile);
-	const resolvedRoots = roots.filter((root) => typeof root === "string" && root.length > 0).map((root) => path.resolve(root));
-	if (path.isAbsolute(normalizedFile)) for (const root of resolvedRoots) {
-		const relative = path.relative(root, normalizedFile);
-		if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) addBase(relative);
-	}
-	else for (const root of resolvedRoots) addBase(path.resolve(root, normalizedFile));
-	return bases;
-}
-function collectParentDirectories(file) {
-	const directories = [];
-	let current = path.dirname(path.resolve(file.replace(/[?#].*$/, "")));
-	while (true) {
-		directories.push(current);
-		const parent = path.dirname(current);
-		if (parent === current) break;
-		current = parent;
-	}
-	return directories;
-}
-function hasMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) {
-	return scoreMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) > 0;
-}
-function scoreMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) {
-	const outputBases = collectStyleFileMatchBases(outputFile, [outputRoot]);
-	const sourceBases = collectStyleFileMatchBases(sourceFile, [sourceRoot, ...collectParentDirectories(sourceFile)]);
-	let bestScore = 0;
-	for (const outputBase of outputBases) for (const sourceBase of sourceBases) if (outputBase === sourceBase) bestScore = Math.max(bestScore, 1e5 + outputBase.length);
-	else if (outputBase.endsWith(`/${sourceBase}`)) bestScore = Math.max(bestScore, 5e4 + sourceBase.length);
-	else if (sourceBase.endsWith(`/${outputBase}`)) bestScore = Math.max(bestScore, 1e3 + outputBase.length);
-	return bestScore;
-}
-function findRememberedCssSource(sources, outputFile, file, originalSource, outputRoot, sourceRoot) {
-	if (!sources) return;
-	const rememberedSources = [...sources].map(([, remembered]) => remembered);
-	const originalFiles = [
-		file,
-		originalSource.originalFileName,
-		...originalSource.originalFileNames ?? []
-	].filter((item) => typeof item === "string" && item.length > 0);
-	const sourceMatched = rememberedSources.find((remembered) => originalFiles.some((originalFile) => normalizeOutputPathKey(remembered.sourceFile) === normalizeOutputPathKey(originalFile)));
-	if (sourceMatched) return sourceMatched;
-	const outputMatched = rememberedSources.find((remembered) => normalizeOutputPathKey(remembered.outputFile) === normalizeOutputPathKey(outputFile));
-	if (outputMatched) return outputMatched;
-	const scoredMatches = rememberedSources.filter((remembered) => !(isMainAppCssFile(outputFile) && isAppOriginCssFile(remembered.outputFile))).map((remembered) => ({
-		remembered,
-		score: Math.max(scoreMatchingStyleFileBase(outputFile, remembered.sourceFile, outputRoot, sourceRoot), scoreMatchingStyleFileBase(outputFile, remembered.outputFile, outputRoot, sourceRoot))
-	})).filter((match) => match.score > 0).sort((a, b) => b.score - a.score);
-	const bestScore = scoredMatches[0]?.score;
-	return bestScore && scoredMatches.filter((match) => match.score === bestScore).length === 1 ? scoredMatches[0]?.remembered : void 0;
-}
-function collectConfiguredTailwindV4CssSources(opts) {
-	const patcherCssSources = opts.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssSources ?? [];
-	return [...opts.tailwindcss?.v4?.cssSources ?? [], ...patcherCssSources ?? []];
-}
-function collectConfiguredCssEntries(opts) {
-	const patcherCssEntries = opts.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssEntries ?? [];
-	return [
-		...opts.cssEntries ?? [],
-		...opts.tailwindcss?.v4?.cssEntries ?? [],
-		...patcherCssEntries ?? []
-	].filter((entry) => typeof entry === "string" && entry.length > 0);
-}
-function collectCssConfigBaseCandidates(source, file, outputRoot, opts) {
-	const candidates = [];
-	const seen = /* @__PURE__ */ new Set();
-	const addCandidate = (candidate) => {
-		if (!candidate) return;
-		const normalized = path.resolve(candidate);
-		if (seen.has(normalized)) return;
-		seen.add(normalized);
-		candidates.push(normalized);
-	};
-	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 configuredCssEntries = collectConfiguredCssEntries(opts);
-	for (const cssEntry of configuredCssEntries) {
-		const resolvedCssEntry = path.resolve(cssEntry);
-		if (configuredCssEntries.length === 1 || isMatchingCssSourceFile(file, resolvedCssEntry, outputRoot) || hasMatchingStyleFileBase(file, resolvedCssEntry, outputRoot, sourceRoot)) addCandidate(path.dirname(resolvedCssEntry));
-	}
-	for (const cssSource of collectConfiguredTailwindV4CssSources(opts)) {
-		const cssSourceFile = normalizeMatchedCssSourcePath(cssSource.file);
-		const cssSourceCss = typeof cssSource.css === "string" ? normalizeCssSourceForCompare(cssSource.css) : void 0;
-		if (cssSourceFile && !isMatchingCssSourceFile(file, cssSourceFile, outputRoot) && cssSourceCss !== normalizedSource) continue;
-		addCandidate(cssSourceFile ? path.dirname(cssSourceFile) : void 0);
-		addCandidate(resolveTailwindV4CssSourceBase(cssSource, sourceBaseFallback));
-	}
-	return candidates;
-}
-function normalizeRelativeCssConfigDirectives(source, file, outputRoot, opts) {
-	if (!source.includes("@config")) return source;
-	const baseCandidates = collectCssConfigBaseCandidates(source, file, outputRoot, opts);
-	return source.replace(/@config\s+(["'])(.+?)\1\s*;?/g, (full, quote, request) => {
-		if (path.isAbsolute(request) || isPackageJsonImportRequest(request)) return full;
-		for (const base of baseCandidates) {
-			const configFile = path.resolve(base, request);
-			if (existsSync(configFile)) return `@config ${quote}${slash(configFile)}${quote};`;
-		}
-		return full;
-	});
-}
 function createGenerateBundleHook(context) {
 	const state = createBundleBuildState();
 	const lastCssResultByFile = /* @__PURE__ */ new Map();
 	let currentOutDir;
+	let currentSubpackageRoots;
 	const cssHandlerOptions = createCssHandlerOptionsCache({
 		getAppType: () => context.opts.appType,
 		mainCssChunkMatcher: context.opts.mainCssChunkMatcher,
@@ -1361,26 +2489,36 @@ function createGenerateBundleHook(context) {
 	});
 	return async function generateBundle(_opt, bundle) {
 		const addWatchFile = (id) => this.addWatchFile?.(id);
-		const { opts, runtimeState, ensureBundleRuntimeClassSet, debug, getResolvedConfig, markCssAssetProcessed, isCssAssetProcessed, isViteProcessedCssAsset, recordCssAssetResult, recordViteProcessedCssAssetResult, getViteProcessedCssAssetResults, getViteProcessedCssAssetResult, getSourceCandidates, getSourceCandidatesForEntries, waitForSourceCandidateSyncs, rememberCssSource, refreshRememberedCssSource, getRememberedCssSources, getRememberedCssSignature, setRememberedCssSignature, recordGeneratorCandidates, hmrTimingRecorder } = context;
+		const { opts, runtimeState, ensureBundleRuntimeClassSet, debug, getResolvedConfig, markCssAssetProcessed, isCssAssetProcessed, isViteProcessedCssAsset, recordCssAssetResult, recordViteProcessedCssAssetResult, getViteProcessedCssAssetResults, getViteProcessedCssAssetResult, getSourceCandidates, getSourceCandidatesForEntries, getSourceCandidateSourcesForEntries, waitForSourceCandidateSyncs, rememberCssSource, refreshRememberedCssSource, getRememberedCssSources, getRememberedCssSignature, setRememberedCssSignature, getKnownSfcSource, recordGeneratorCandidates, hmrTimingRecorder } = context;
+		const getBundlerSfcSource = (sourceFile) => {
+			const code = this.getModuleInfo?.(sourceFile)?.code;
+			return typeof code === "string" && hasSfcStyleSources(code) ? code : void 0;
+		};
+		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 isNativeAppStyleTarget = resolveUniUtsPlatform().isApp;
+		const resolvedConfig = getResolvedConfig();
+		const uniUtsPlatform = resolveUniUtsPlatform();
+		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 { getCssHandlerOptions, getCssUserHandlerOptions } = cssHandlerOptions;
-		const resolvedConfig = getResolvedConfig();
 		const rootDir = resolvedConfig?.root ? path.resolve(resolvedConfig.root) : process$1.cwd();
 		const outDir = resolvedConfig?.build?.outDir ? path.resolve(rootDir, resolvedConfig.build.outDir) : rootDir;
 		await runtimeState.readyPromise;
 		debug("start");
 		onStart();
+		const collectedBundlerGeneratedCssFiles = new Set(Object.entries(bundle).filter(([, output]) => output.type === "asset" && hasBundlerGeneratedCssMarker(output.source)).map(([file]) => file));
 		collectViteProcessedCssAssetResults(bundle, {
 			opts,
 			isViteProcessedCssAsset,
 			markCssAssetProcessed,
 			recordCssAssetResult,
 			recordViteProcessedCssAssetResult,
-			resolveViteProcessedCssOutputFile: (file) => resolveViteCssPipelineOutputFile(file, opts, rootDir, isWebGeneratorTarget, isNativeAppStyleTarget),
+			resolveViteProcessedCssOutputFile: (file) => resolveViteCssPipelineOutputFile(file, opts, rootDir, isWebGeneratorTarget, shouldPreserveAppCssExtension),
 			debug
 		});
 		const hmrTimingStartedAt = performance.now();
@@ -1403,6 +2541,9 @@ function createGenerateBundleHook(context) {
 		const debugCssDiff = process$1.env["WEAPP_TW_VITE_DEBUG_CSS_DIFF"] === "1";
 		const disableV3OxideSourceRuntime = process$1.env["WEAPP_TW_VITE_DISABLE_V3_OXIDE_RUNTIME"] === "1";
 		const bundleFiles = Object.keys(bundle);
+		const subpackageRoots = collectMiniProgramSubpackageRoots(bundle);
+		if (subpackageRoots) currentSubpackageRoots = subpackageRoots;
+		const isMainPackageStyleOutputFile = (file) => currentSubpackageRoots != null && !isSubpackageOutputFile(file, currentSubpackageRoots);
 		const buildCommand = resolvedConfig?.command === "build";
 		const hasPreviousBundleState = state.iteration > 0 || state.sourceHashByFile.size > 0;
 		const hasOmittedKnownFiles = hasOmittedKnownBundleFiles(bundleFiles, state.sourceHashByFile.keys());
@@ -1410,6 +2551,29 @@ function createGenerateBundleHook(context) {
 		currentOutDir = outDir;
 		const snapshotStart = performance.now();
 		const snapshot = buildBundleSnapshot(bundle, opts, outDir, state, disableDirtyOptimization || !useIncrementalMode, { hasOmittedKnownFiles });
+		const subpackageSourceExcludeEntries = currentSubpackageRoots ? collectMiniProgramSubpackageSourceEntries(snapshot, currentSubpackageRoots, [
+			rootDir,
+			opts.tailwindcssBasedir,
+			opts.tailwindcssPatcherOptions?.projectRoot
+		]) : [];
+		const shouldExcludeSubpackageSourceCandidates = (outputFile, cssHandlerOptions) => cssHandlerOptions.isMainChunk === true && subpackageSourceExcludeEntries.length > 0 && isMainPackageStyleOutputFile(outputFile);
+		const createScopedSourceCandidateGetter = (outputFile, cssHandlerOptions) => {
+			if (!getSourceCandidatesForEntries) return;
+			if (!shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions)) return getSourceCandidatesForEntries;
+			return (entries, options) => getSourceCandidatesForEntries(entries, {
+				...options,
+				excludeEntries: [...options?.excludeEntries ?? [], ...subpackageSourceExcludeEntries]
+			});
+		};
+		const createScopedSourceCandidateSourceGetter = (outputFile, cssHandlerOptions) => {
+			if (!getSourceCandidateSourcesForEntries) return;
+			if (!shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions)) return getSourceCandidateSourcesForEntries;
+			return (entries, options) => getSourceCandidateSourcesForEntries(entries, {
+				...options,
+				excludeEntries: [...options?.excludeEntries ?? [], ...subpackageSourceExcludeEntries]
+			});
+		};
+		const shouldInjectCssIntoMainFromOutput = (outputFile, sourceFile, outputCssHandlerOptions) => isMainStyleEntryCssFile(sourceFile) || isTailwindEntryCssFile(outputFile) || useIncrementalMode && (outputCssHandlerOptions.isMainChunk || isMainPackageStyleOutputFile(outputFile));
 		recordTimingDetail("snapshot", snapshotStart);
 		const useBundleRuntimeClassSet = !isWebGeneratorTarget && (useIncrementalMode || runtimeState.twPatcher.majorVersion === 4);
 		const forceRuntimeRefreshBySource = useIncrementalMode && hasRuntimeAffectingSourceChanges(snapshot.runtimeAffectingChangedByType);
@@ -1424,6 +2588,12 @@ function createGenerateBundleHook(context) {
 		await waitForSourceCandidateSyncs?.();
 		recordTimingDetail("sourceCandidates.wait", sourceCandidateWaitStart);
 		const sourceCandidates = getSourceCandidates?.() ?? /* @__PURE__ */ new Set();
+		const createScopedGeneratorRuntime = (outputFile, cssHandlerOptions, runtime) => {
+			if (!shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions)) return runtime;
+			const filteredSourceCandidates = createScopedSourceCandidateGetter(outputFile, cssHandlerOptions)?.(void 0);
+			if (!filteredSourceCandidates) return runtime;
+			return filteredSourceCandidates.size > 0 ? filteredSourceCandidates : runtime;
+		};
 		const jsEntries = snapshot.jsEntries;
 		const getJsEntry = createJsEntryResolver(jsEntries);
 		const moduleGraphOptions = createBundleModuleGraphOptions(outDir, jsEntries);
@@ -1432,10 +2602,11 @@ function createGenerateBundleHook(context) {
 		const useV3OxideSourceRuntime = runtimeState.twPatcher.majorVersion === 3 && sourceCandidates.size > 0 && hasCssAssetEntry && !forceRuntimeRefreshByEnv && !disableV3OxideSourceRuntime;
 		const runtimeStart = performance.now();
 		const transformBaseRuntime = useV3OxideSourceRuntime ? await ensureBundleRuntimeClassSet(snapshot, forceRuntimeRefreshByEnv, { transformOnly: true }) : void 0;
+		const forceV4RuntimeRefreshBySource = runtimeState.twPatcher.majorVersion === 4 && forceRuntimeRefreshBySource;
 		const runtime = isWebGeneratorTarget && !shouldGenerateWebCssByGenerator ? /* @__PURE__ */ new Set() : useV3OxideSourceRuntime ? await ensureBundleRuntimeClassSet(snapshot, forceRuntimeRefreshByEnv, {
 			allowBaselineOnlyInitialSync: true,
 			baseClassSet: sourceCandidates
-		}) : useBundleRuntimeClassSet ? await ensureBundleRuntimeClassSet(snapshot, forceRuntimeRefreshByEnv, { allowBaselineOnlyInitialSync: buildCommand }) : await context.ensureRuntimeClassSet(forceRuntimeRefreshByEnv);
+		}) : useBundleRuntimeClassSet ? await ensureBundleRuntimeClassSet(snapshot, forceRuntimeRefreshByEnv || forceV4RuntimeRefreshBySource, { allowBaselineOnlyInitialSync: buildCommand }) : await context.ensureRuntimeClassSet(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 collectedGeneratorCandidates = new Set([...runtime, ...sourceCandidates]);
@@ -1546,7 +2717,7 @@ function createGenerateBundleHook(context) {
 			if (type === "css" && originalSource.type === "asset") {
 				metrics.css.total++;
 				const rawSource = normalizeRelativeCssConfigDirectives(originalEntrySource, file, outDir, opts);
-				const outputFile = resolveViteCssOutputFile(file, opts, isWebGeneratorTarget);
+				const outputFile = resolveViteCssOutputFile(file, opts, isWebGeneratorTarget, shouldPreserveAppCssExtension);
 				if (outputFile !== file && !canProcessViteSourceStyleAsCss(rawSource, file)) {
 					delete bundle[file];
 					debug("css skip raw source style asset: %s -> %s", file, outputFile);
@@ -1576,43 +2747,66 @@ function createGenerateBundleHook(context) {
 				const viteProcessedCssAsset = isViteProcessedCssAsset?.(originalSource, file) === true || hasViteProcessedCssRecord;
 				const cssAssetProcessed = isCssAssetProcessed?.(originalSource, file) === true;
 				const alreadyProcessedCssAsset = viteProcessedCssAsset || cssAssetProcessed;
-				let rememberedCssSource = findRememberedCssSource(getRememberedCssSources?.(), outputFile, file, originalSource, outDir, opts.tailwindcssBasedir);
-				if (rememberedCssSource != null) rememberedCssSource = await refreshRememberedCssSource?.(rememberedCssSource) ?? rememberedCssSource;
+				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));
+				const inferredSfcStyleSource = await resolveSfcStyleSourceFromOutputFile(outputFile, snapshot, outDir, opts.tailwindcssBasedir, 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];
+				}
+				const rememberedCssSource = mergeRememberedCssSources(rememberedCssSources, outputFile);
 				const useRememberedCssSource = rememberedCssSource != null && normalizeOutputPathKey(rememberedCssSource.sourceFile) !== normalizeOutputPathKey(file);
 				const vitePipelineCssAsset = viteProcessedCssAsset || useRememberedCssSource;
 				const generatorRawSource = vitePipelineCssAsset ? rememberedCssSource?.rawSource ?? rawSource : rawSource;
 				const hasRememberedApplySource = vitePipelineCssAsset && rememberedCssSource != null && hasTailwindApplyDirective(generatorRawSource);
 				const hasDifferentRememberedCssSource = rememberedCssSource != null && normalizeCssSourceForCompare(rememberedCssSource.rawSource) !== normalizeCssSourceForCompare(rawSource);
-				const hasCurrentTailwindGenerationDirective = hasTailwindRootDirectives(rawSource, { importFallback: true }) || hasTailwindApplyDirective(rawSource);
+				const hasCurrentTailwindGenerationDirective = hasTailwindSourceDirectives(rawSource, { importFallback: true }) || hasTailwindRootDirectives(rawSource, { importFallback: true }) || hasTailwindApplyDirective(rawSource);
 				const hasRememberedApplyDirective = rememberedCssSource != null && hasTailwindApplyDirective(rememberedCssSource.rawSource);
 				const hasStaleViteProcessedCssSource = vitePipelineCssAsset && hasDifferentRememberedCssSource && (hasCurrentTailwindGenerationDirective || hasRememberedApplyDirective);
 				const generatorSourceFile = vitePipelineCssAsset ? rememberedCssSource?.sourceFile ?? file : file;
 				const outputCssHandlerOptions = getCssHandlerOptions(outputFile);
 				const cssHandlerOptions = vitePipelineCssAsset ? {
 					...getCssHandlerOptions(generatorSourceFile),
-					isMainChunk: outputCssHandlerOptions.isMainChunk || isAppOriginCssFile(file)
+					isMainChunk: outputCssHandlerOptions.isMainChunk || isAppOriginCssFile(file) || isMainStyleEntryCssFile(generatorSourceFile)
 				} : getCssHandlerOptions(file);
+				const scopedSourceCandidateGetter = createScopedSourceCandidateGetter(outputFile, cssHandlerOptions);
+				const scopedSourceCandidateSourceGetter = createScopedSourceCandidateSourceGetter(outputFile, cssHandlerOptions);
+				const sourceTraceTokenSources = scopedSourceCandidateSourceGetter ? createCssTokenSourceMap(scopedSourceCandidateSourceGetter(void 0), opts) : void 0;
+				const sourceTraceSignature = createCssSourceTraceCacheSignature(sourceTraceTokenSources, opts);
+				const scopedGeneratorRuntime = createScopedGeneratorRuntime(outputFile, cssHandlerOptions, generatorRuntime);
+				const annotateCss = (css) => annotateCssSourceTrace(css, {
+					opts,
+					tokenSources: sourceTraceTokenSources
+				});
+				const shouldRegenerateMainPackageCssWithScopedCandidates = vitePipelineCssAsset && shouldExcludeSubpackageSourceCandidates(outputFile, cssHandlerOptions);
 				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 shouldRegenerateAppOriginCss = viteProcessedCssAsset && isAppOriginCssFile(file);
-				const shouldTrackGeneratorRuntime = hasStaleViteProcessedCssSource || shouldProcessTailwindGeneration && (!useIncrementalMode || cssHandlerOptions.isMainChunk || processFiles.css.has(file) || runtimeLinkedCssFiles.has(file) || shouldRegenerateAppOriginCss);
-				const canRegenerateProcessedMainCss = cssHandlerOptions.isMainChunk && (getViteProcessedCssAssetResult?.(file)?.injectIntoMain === true || shouldRegenerateAppOriginCss);
-				if (alreadyProcessedCssAsset && !hasStaleViteProcessedCssSource && !hasRememberedApplySource && (!shouldTrackGeneratorRuntime || !canRegenerateProcessedMainCss)) {
+				const shouldTrackGeneratorRuntime = hasStaleViteProcessedCssSource || shouldRegenerateMainPackageCssWithScopedCandidates || hasCurrentTailwindGenerationDirective || shouldProcessTailwindGeneration && (!useIncrementalMode || cssHandlerOptions.isMainChunk || processFiles.css.has(file) || runtimeLinkedCssFiles.has(file) || shouldRegenerateAppOriginCss || hasRuntimeAffectingChanges && (alreadyProcessedCssAsset || vitePipelineCssAsset));
+				const shouldPreserveCollectedViteCssAsset = !shouldRegenerateAppOriginCss && (collectedBundlerGeneratedCssFiles.has(file) || hasBundlerGeneratedCssMarker(rawSource));
+				if (alreadyProcessedCssAsset && !hasStaleViteProcessedCssSource && !hasRememberedApplySource && !shouldRegenerateMainPackageCssWithScopedCandidates && (!shouldTrackGeneratorRuntime || shouldPreserveCollectedViteCssAsset)) {
 					const nextCss = stripBundlerGeneratedCssMarkers(rawSource);
 					applyCssResult(nextCss);
 					markCssAssetProcessed?.(originalSource, outputFile);
 					recordCssAssetResult?.(outputFile, nextCss);
+					const shouldInjectPreservedViteCssIntoMain = vitePipelineCssAsset && !isAppOriginCssFile(file) && shouldInjectCssIntoMainFromOutput(outputFile, generatorSourceFile, outputCssHandlerOptions);
+					recordViteProcessedCssAssetResult?.(outputFile, nextCss, {
+						injectIntoMain: isAppOriginCssFile(file) ? false : shouldInjectPreservedViteCssIntoMain,
+						outputFile
+					});
 					onUpdate(outputFile, rawSource, nextCss);
 					debug("css skip vite-processed asset: %s", outputFile);
 					continue;
 				}
-				const trackedGeneratorCandidateSignature = shouldTrackGeneratorRuntime ? generatorCandidateSignature : "generator:stable";
-				const scopedGeneratorCandidateSignature = shouldTrackGeneratorRuntime ? await createScopedGeneratorCandidateSignature(generatorRawSource, generatorSourceFile, trackedGeneratorCandidateSignature, getSourceCandidatesForEntries, { includeFallbackSignature: cssHandlerOptions.isMainChunk }) : trackedGeneratorCandidateSignature;
+				const trackedGeneratorCandidateSignature = shouldTrackGeneratorRuntime ? createCandidateSignature(scopedGeneratorRuntime) : "generator:stable";
+				const scopedGeneratorCandidateSignature = shouldTrackGeneratorRuntime ? await createScopedGeneratorCandidateSignature(generatorRawSource, generatorSourceFile, trackedGeneratorCandidateSignature, scopedSourceCandidateGetter, { includeFallbackSignature: cssHandlerOptions.isMainChunk }) : trackedGeneratorCandidateSignature;
 				const cssRuntimeSignature = createCssRuntimeSignature(runtimeSignature, scopedGeneratorCandidateSignature);
 				const rememberedCssRuntimeSignature = createRememberedCssRuntimeSignature(cssRuntimeSignature, cssRuntimeAffectingHash);
-				const cssSharedCacheKey = `${cssShareScope}:${cssRuntimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}:${cssHandlerOptions.isMainChunk ? "1" : "0"}:${cssRuntimeAffectingSignature}`;
+				const cssSharedCacheKey = `${cssShareScope}:${cssRuntimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}:${cssHandlerOptions.isMainChunk ? "1" : "0"}:${cssRuntimeAffectingSignature}:${sourceTraceSignature}`;
 				if (!shouldTrackGeneratorRuntime) {
 					const lastCss = lastCssResultByFile.get(outputFile) ?? lastCssResultByFile.get(file);
 					if (lastCss != null) {
@@ -1627,12 +2821,12 @@ function createGenerateBundleHook(context) {
 					cache,
 					cacheKey: file,
 					hashKey: `${file}:css:${cssRuntimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}`,
-					hash: `${cssRuntimeAffectingHash}:${scopedGeneratorCandidateSignature}`,
+					hash: `${cssRuntimeAffectingHash}:${scopedGeneratorCandidateSignature}:${sourceTraceSignature}`,
 					applyResult(source) {
 						applyCssResult(source);
 						lastCssResultByFile.set(outputFile, source);
 						markCssAssetProcessed?.(originalSource, outputFile);
-						rememberCssSource?.({
+						if (rememberedCssSources.length <= 1) rememberCssSource?.({
 							outputFile,
 							rawSource: generatorRawSource,
 							sourceFile: generatorSourceFile
@@ -1656,43 +2850,51 @@ function createGenerateBundleHook(context) {
 						const runTransform = async () => {
 							const start = performance.now();
 							await runtimeState.readyPromise;
-							const previousCss = !vitePipelineCssAsset && useIncrementalMode && !hasRuntimeAffectingChanges && !snapshot.changedByType.css.has(file) ? lastCssResultByFile.get(outputFile) ?? lastCssResultByFile.get(file) : void 0;
 							const generated = await generateCssByGenerator({
 								opts,
 								runtimeState,
-								runtime: generatorRuntime,
+								runtime: scopedGeneratorRuntime,
 								rawSource: generatorRawSource,
 								file: generatorSourceFile,
 								cssHandlerOptions,
 								cssUserHandlerOptions: generatorCssUserHandlerOptions,
-								getSourceCandidatesForEntries,
+								getSourceCandidatesForEntries: scopedSourceCandidateGetter,
 								styleHandler,
 								debug,
-								previousCss
+								previousCss: !vitePipelineCssAsset && useIncrementalMode && !hasRuntimeAffectingChanges && !snapshot.changedByType.css.has(file) ? lastCssResultByFile.get(outputFile) ?? lastCssResultByFile.get(file) : void 0
 							});
 							if (generated) {
+								const tracedCss = annotateCss(generated.css);
 								registerGeneratorDependencies$1({ addWatchFile }, generated.dependencies);
-								if (debugCssDiff) debug("css diff %s: %s", generatorSourceFile, summarizeStringDiff(generatorRawSource, generated.css));
-								debug("css generated result: %s bytes=%d", file, generated.css.length);
-								recordCssAssetResult?.(outputFile, generated.css);
-								if (vitePipelineCssAsset && cssHandlerOptions.isMainChunk) recordViteProcessedCssAssetResult?.(file, generated.css, { injectIntoMain: !isAppOriginCssFile(file) });
-								if (vitePipelineCssAsset) recordViteProcessedCssAssetResult?.(outputFile, generated.css, { injectIntoMain: false });
+								if (debugCssDiff) debug("css diff %s: %s", generatorSourceFile, summarizeStringDiff(generatorRawSource, tracedCss));
+								debug("css generated result: %s bytes=%d", file, tracedCss.length);
+								recordCssAssetResult?.(outputFile, tracedCss);
+								const shouldInjectVitePipelineCssIntoMain = vitePipelineCssAsset && !isAppOriginCssFile(file) && shouldInjectCssIntoMainFromOutput(outputFile, generatorSourceFile, outputCssHandlerOptions);
+								recordViteProcessedCssAssetResult?.(outputFile, tracedCss, {
+									injectIntoMain: isAppOriginCssFile(file) ? false : shouldInjectVitePipelineCssIntoMain,
+									outputFile
+								});
+								if (vitePipelineCssAsset && shouldInjectVitePipelineCssIntoMain) recordViteProcessedCssAssetResult?.(file, tracedCss, {
+									injectIntoMain: isAppOriginCssFile(file) ? false : shouldInjectVitePipelineCssIntoMain,
+									outputFile
+								});
 								metrics.css.elapsed += measureElapsed(start);
 								metrics.css.transformed++;
 								debug("css handle via tailwind v%s engine(%s): %s", runtimeState.twPatcher.majorVersion, generated.target, outputFile);
-								return generated.css;
+								return tracedCss;
 							}
 							if (isWebGeneratorTarget) {
 								metrics.css.elapsed += measureElapsed(start);
 								metrics.css.transformed++;
 								debug("css preserve web target: %s", outputFile);
-								return rawSource;
+								return annotateCss(rawSource);
 							}
 							const { css } = await styleHandler(generatorRawSource, cssHandlerOptions);
-							if (debugCssDiff) debug("css diff %s: %s", generatorSourceFile, summarizeStringDiff(generatorRawSource, css));
+							const tracedCss = annotateCss(css);
+							if (debugCssDiff) debug("css diff %s: %s", generatorSourceFile, summarizeStringDiff(generatorRawSource, tracedCss));
 							metrics.css.elapsed += measureElapsed(start);
 							metrics.css.transformed++;
-							return css;
+							return tracedCss;
 						};
 						const cssTask = cssSharedCacheKey ? sharedCssResultCache.get(cssSharedCacheKey) ?? runTransform() : runTransform();
 						if (cssSharedCacheKey && !sharedCssResultCache.has(cssSharedCacheKey)) sharedCssResultCache.set(cssSharedCacheKey, cssTask);
@@ -1765,9 +2967,10 @@ function createGenerateBundleHook(context) {
 				const factory = createUniAppXAssetTask(file, originalSource, outDir, {
 					cache,
 					hashKey: `${file}:js`,
-					hashSalt: createJsHashSalt(runtimeSignature, useIncrementalMode ? createLinkedImpactSignature(file, snapshot.linkedImpactsByEntry, snapshot.sourceHashByFile) : void 0),
+					hashSalt: createJsHashSalt(runtimeSignature, [UNI_APP_X_STYLE_PLACEHOLDER_VERSION, useIncrementalMode ? createLinkedImpactSignature(file, snapshot.linkedImpactsByEntry, snapshot.sourceHashByFile) : void 0].filter(Boolean).join(":")),
 					createHandlerOptions,
 					debug,
+					getAssetSource: createUniAppXBundleAssetSourceGetter(bundle),
 					jsHandler,
 					onUpdate,
 					runtimeSet: transformRuntime,
@@ -1804,61 +3007,146 @@ function createGenerateBundleHook(context) {
 				});
 			}
 		}
-		if (useIncrementalMode || isNativeAppStyleTarget) for (const [key, rememberedEntry] of getRememberedCssSources?.() ?? []) {
-			const { outputFile: rememberedOutputFile, rawSource, sourceFile } = await refreshRememberedCssSource?.(rememberedEntry) ?? rememberedEntry;
-			const outputFile = resolveViteCssPipelineOutputFile(rememberedOutputFile, opts, rootDir, isWebGeneratorTarget, isNativeAppStyleTarget);
-			const cssHandlerOptions = getCssHandlerOptions(outputFile);
-			const rememberedCssRuntimeSignature = createRememberedCssRuntimeSignature(createCssRuntimeSignature(runtimeSignature, await createScopedGeneratorCandidateSignature(rawSource, sourceFile, generatorCandidateSignature, getSourceCandidatesForEntries, { includeFallbackSignature: cssHandlerOptions.isMainChunk })), cache.computeHash(createRuntimeAffectingSourceSignature(rawSource, "css")));
-			if (bundleFiles.includes(outputFile) || bundleFiles.includes(sourceFile) || getRememberedCssSignature?.(key) === rememberedCssRuntimeSignature) continue;
-			tasks.push(timeTask("css.replay", async () => {
-				const start = performance.now();
-				const generated = await generateCssByGenerator({
+		if (useIncrementalMode || isNativeAppStyleTarget) {
+			const rememberedReplayGroups = collectRememberedCssReplayGroups(getRememberedCssSources?.(), opts, rootDir, isWebGeneratorTarget, shouldPreserveAppCssExtension);
+			for (const [outputFile, rememberedGroup] of rememberedReplayGroups) {
+				const refreshedRememberedGroup = await Promise.all(rememberedGroup.map(async (item) => ({
+					key: item.key,
+					remembered: await refreshRememberedCssSource?.(item.remembered) ?? item.remembered
+				})));
+				const rememberedCssSource = mergeRememberedCssSources(refreshedRememberedGroup.map((item) => item.remembered), outputFile);
+				if (!rememberedCssSource) continue;
+				const { rawSource, sourceFile } = rememberedCssSource;
+				const outputCssHandlerOptions = getCssHandlerOptions(outputFile);
+				const cssHandlerOptions = {
+					...getCssHandlerOptions(sourceFile),
+					isMainChunk: outputCssHandlerOptions.isMainChunk || isMainStyleEntryCssFile(sourceFile)
+				};
+				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,
-					runtimeState,
-					runtime: generatorRuntime,
-					rawSource,
-					file: sourceFile,
-					cssHandlerOptions,
-					cssUserHandlerOptions: getCssUserHandlerOptions(outputFile),
-					getSourceCandidatesForEntries,
-					styleHandler,
-					debug
-				});
-				const css = generated?.css ?? (await styleHandler(rawSource, cssHandlerOptions)).css;
-				setRememberedCssSignature?.(key, rememberedCssRuntimeSignature);
-				if (generated) {
-					registerGeneratorDependencies$1({ addWatchFile }, generated.dependencies);
-					recordCssAssetResult?.(outputFile, generated.css);
-					recordViteProcessedCssAssetResult?.(sourceFile, generated.css, { injectIntoMain: cssHandlerOptions.isMainChunk });
-					debug("css replay generated result: %s bytes=%d", outputFile, css.length);
-				}
-				const replayAsset = createReplayCssAsset(outputFile, css);
-				if (typeof this.emitFile === "function") this.emitFile({
-					type: "asset",
-					fileName: outputFile,
-					source: css
+					tokenSources: sourceTraceTokenSources
 				});
-				else bundle[outputFile] = replayAsset;
-				markCssAssetProcessed?.(replayAsset, outputFile);
-				metrics.css.elapsed += measureElapsed(start);
-				metrics.css.transformed++;
-				onUpdate(outputFile, rawSource, css);
-				debug("css replay handle: %s", outputFile);
-			}));
+				const scopedGeneratorRuntime = createScopedGeneratorRuntime(outputFile, cssHandlerOptions, generatorRuntime);
+				const rememberedCssRuntimeSignature = createRememberedCssRuntimeSignature(createCssRuntimeSignature(createCandidateSignature(scopedGeneratorRuntime), await createScopedGeneratorCandidateSignature(rawSource, sourceFile, createCandidateSignature(scopedGeneratorRuntime), scopedSourceCandidateGetter, { includeFallbackSignature: cssHandlerOptions.isMainChunk })), cache.computeHash(createRuntimeAffectingSourceSignature(rawSource, "css")));
+				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;
+				tasks.push(timeTask("css.replay", async () => {
+					const start = performance.now();
+					const generated = await generateCssByGenerator({
+						opts,
+						runtimeState,
+						runtime: scopedGeneratorRuntime,
+						rawSource,
+						file: sourceFile,
+						cssHandlerOptions,
+						cssUserHandlerOptions: getCssUserHandlerOptions(sourceFile),
+						getSourceCandidatesForEntries: scopedSourceCandidateGetter,
+						styleHandler,
+						debug
+					});
+					const css = annotateCss(generated?.css ?? (await styleHandler(rawSource, cssHandlerOptions)).css);
+					for (const key of rememberedKeys) setRememberedCssSignature?.(key, rememberedCssRuntimeSignature);
+					if (generated) {
+						registerGeneratorDependencies$1({ addWatchFile }, generated.dependencies);
+						recordCssAssetResult?.(outputFile, css);
+						const shouldInjectReplayCssIntoMain = shouldInjectCssIntoMainFromOutput(outputFile, sourceFile, outputCssHandlerOptions);
+						recordViteProcessedCssAssetResult?.(sourceFile, css, {
+							injectIntoMain: isAppOriginCssFile(outputFile) ? false : shouldInjectReplayCssIntoMain,
+							outputFile
+						});
+						debug("css replay generated result: %s bytes=%d", outputFile, css.length);
+					}
+					const replayAsset = createReplayCssAsset(outputFile, css);
+					if (typeof this.emitFile === "function") this.emitFile({
+						type: "asset",
+						fileName: outputFile,
+						source: css
+					});
+					else bundle[outputFile] = replayAsset;
+					markCssAssetProcessed?.(replayAsset, outputFile);
+					metrics.css.elapsed += measureElapsed(start);
+					metrics.css.transformed++;
+					onUpdate(outputFile, rawSource, css);
+					debug("css replay handle: %s", outputFile);
+				}));
+			}
 		}
 		pushConcurrentTaskFactories(tasks, jsTaskFactories);
 		const tasksStart = performance.now();
 		await Promise.all(tasks);
 		recordTimingDetail("tasks", tasksStart);
 		for (const apply of pendingLinkedUpdates) apply();
-		injectViteProcessedCssIntoMainCssAssets(bundle, {
-			opts,
-			getViteProcessedCssAssetResults,
-			markCssAssetProcessed,
-			recordCssAssetResult,
-			debug,
-			onUpdate
-		});
+		const applyStyleSources = collectUniAppXHarmonyApplyStyleSources(bundle);
+		if (opts.appType === "uni-app-x" || isNativeAppStyleTarget || isHarmonyAppStyleTarget) {
+			const getAssetSource = createUniAppXBundleAssetSourceGetter(bundle);
+			const viteProcessedCssSources = [...getViteProcessedCssAssetResults?.() ?? []].map(([, record]) => typeof record === "string" ? record : record.css);
+			const applyUtilities = collectUniAppXHarmonyApplyUtilities(bundle);
+			const shouldInjectHarmonyBundleStyles = isHarmonyAppStyleTarget;
+			if (shouldInjectHarmonyBundleStyles) {
+				if (applyUtilities.size > 0 && applyStyleSources.length > 0) {
+					const outputFile = "uni-app-x-harmony-apply.css";
+					const cssHandlerOptions = getCssHandlerOptions(outputFile);
+					const generated = await generateCssByGenerator({
+						opts,
+						runtimeState,
+						runtime: new Set([...generatorRuntime, ...applyUtilities]),
+						rawSource: createUniAppXHarmonyApplyGeneratorSource(applyStyleSources, applyUtilities),
+						file: outputFile,
+						cssHandlerOptions,
+						cssUserHandlerOptions: {
+							...cssHandlerOptions,
+							isMainChunk: false
+						},
+						getSourceCandidatesForEntries,
+						styleHandler,
+						debug
+					});
+					if (generated?.css) viteProcessedCssSources.push(annotateCssSourceTrace(generated.css, {
+						opts,
+						tokenSources: getSourceCandidateSourcesForEntries ? createCssTokenSourceMap(getSourceCandidateSourcesForEntries(void 0), opts) : void 0
+					}));
+				}
+			}
+			if (shouldInjectHarmonyBundleStyles && injectUniAppXHarmonyBundleStyles(bundle, { cssSources: viteProcessedCssSources })) debug("uni-app-x harmony bundle styles inject");
+			for (const [file, item] of Object.entries(bundle)) {
+				if (item.type !== "asset" || !file.endsWith(".uvue.ts")) continue;
+				const currentSource = String(item.source);
+				const nextSource = injectUniAppXStylePlaceholder(file, currentSource, getAssetSource);
+				if (nextSource !== currentSource) {
+					item.source = nextSource;
+					onUpdate(file, currentSource, nextSource);
+					debug("uni-app-x style placeholder inject: %s", file);
+				}
+			}
+		}
+		const syncViteProcessedCssIntoMainCssAssets = () => {
+			collectViteProcessedCssAssetResults(bundle, {
+				opts,
+				isViteProcessedCssAsset,
+				markCssAssetProcessed,
+				recordCssAssetResult,
+				recordViteProcessedCssAssetResult,
+				resolveViteProcessedCssOutputFile: (file) => resolveViteCssPipelineOutputFile(file, opts, rootDir, isWebGeneratorTarget, shouldPreserveAppCssExtension),
+				debug
+			});
+			return injectViteProcessedCssIntoMainCssAssets(bundle, {
+				opts,
+				getViteProcessedCssAssetResults,
+				markCssAssetProcessed,
+				recordCssAssetResult,
+				debug,
+				onUpdate
+			});
+		};
+		syncViteProcessedCssIntoMainCssAssets();
+		if (isHarmonyAppStyleTarget && applyStyleSources.length > 0) {
+			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();
+		}
 		const stateUpdateStart = performance.now();
 		updateBundleBuildState(state, snapshot, useIncrementalMode ? linkedByEntry ?? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map(), { incremental: useIncrementalMode });
 		state.generatorCandidateSignature = generatorCandidateSignature;
@@ -1909,6 +3197,9 @@ function shouldGenerateCssByGenerator(opts, file, rawSource, processed) {
 function shouldFinalizeProcessedCssAsset(opts, file) {
 	return opts.mainCssChunkMatcher(file, opts.appType);
 }
+function collectViteProcessedCssSources(getViteProcessedCssAssetResults) {
+	return [...getViteProcessedCssAssetResults?.() ?? []].map(([, record]) => typeof record === "string" ? record : record.css);
+}
 function createViteCssFinalizerOutputPlugin(context) {
 	return {
 		name: "weapp-tailwindcss:adaptor:css-finalizer",
@@ -1916,29 +3207,34 @@ function createViteCssFinalizerOutputPlugin(context) {
 		generateBundle: {
 			order: "post",
 			async handler(_options, bundle) {
-				const { opts, runtimeState, ensureRuntimeClassSet, isCssAssetProcessed, markCssAssetProcessed, debug, getResolvedConfig, recordCssAssetResult, recordViteProcessedCssAssetResult, getViteProcessedCssAssetResults, getRecordedGeneratorCandidates, getSourceCandidates, getSourceCandidatesForEntries, waitForSourceCandidateSyncs, rememberMainCssSource, getRememberedMainCssSource, isViteProcessedCssAsset } = context;
+				const { opts, runtimeState, ensureRuntimeClassSet, isCssAssetProcessed, markCssAssetProcessed, debug, getResolvedConfig, recordCssAssetResult, recordViteProcessedCssAssetResult, getViteProcessedCssAssetResults, getRecordedGeneratorCandidates, getSourceCandidates, getSourceCandidatesForEntries, getSourceCandidateSourcesForEntries, waitForSourceCandidateSyncs, rememberMainCssSource, getRememberedMainCssSource, isViteProcessedCssAsset } = context;
 				const resolvedConfig = getResolvedConfig();
-				if (resolvedConfig?.command !== "build") return;
 				const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator);
 				const isWebGeneratorTarget = generatorOptions.target === "web";
-				const isNativeAppStyleTarget = resolveUniUtsPlatform().isApp;
-				const rootDir = resolvedConfig.root ? path.resolve(resolvedConfig.root) : process$1.cwd();
-				collectViteProcessedCssAssetResults(bundle, {
+				const uniUtsPlatform = resolveUniUtsPlatform();
+				const canInferHarmonyAppStyleTarget = !uniUtsPlatform.normalized || uniUtsPlatform.isApp;
+				const isHarmonyAppStyleTarget = uniUtsPlatform.isAppHarmony || canInferHarmonyAppStyleTarget && (isUniAppXHarmonyBundle(bundle) || isUniAppXHarmonyOutDir(resolvedConfig?.build?.outDir));
+				const isNativeAppStyleTarget = uniUtsPlatform.isApp || isHarmonyAppStyleTarget;
+				if (resolvedConfig?.command !== "build" && !isNativeAppStyleTarget) return;
+				const rootDir = resolvedConfig?.root ? path.resolve(resolvedConfig.root) : process$1.cwd();
+				const sourceTraceTokenSources = getSourceCandidateSourcesForEntries ? createCssTokenSourceMap(getSourceCandidateSourcesForEntries(void 0), opts) : void 0;
+				const annotateCss = (css) => annotateCssSourceTrace(css, {
 					opts,
-					isViteProcessedCssAsset,
-					markCssAssetProcessed,
-					recordCssAssetResult,
-					recordViteProcessedCssAssetResult,
-					resolveViteProcessedCssOutputFile: (file) => resolveViteCssPipelineOutputFile(file, opts, rootDir, isWebGeneratorTarget, isNativeAppStyleTarget),
-					debug
+					tokenSources: sourceTraceTokenSources
 				});
-				const isCssOutputAssetEntry = (entry) => {
-					const [, output] = entry;
-					return output.type === "asset" && opts.cssMatcher(output.fileName) && !isCssAssetProcessed(output, output.fileName);
+				const collectViteProcessedCssAssets = () => {
+					collectViteProcessedCssAssetResults(bundle, {
+						opts,
+						isViteProcessedCssAsset,
+						markCssAssetProcessed,
+						recordCssAssetResult,
+						recordViteProcessedCssAssetResult,
+						resolveViteProcessedCssOutputFile: (file) => resolveViteCssPipelineOutputFile(file, opts, rootDir, isWebGeneratorTarget, isNativeAppStyleTarget),
+						debug
+					});
 				};
-				const entries = Object.entries(bundle).filter(isCssOutputAssetEntry);
-				if (entries.length === 0) {
-					injectViteProcessedCssIntoMainCssAssets(bundle, {
+				const injectViteProcessedCssIntoMainCss = () => {
+					return injectViteProcessedCssIntoMainCssAssets(bundle, {
 						opts,
 						getViteProcessedCssAssetResults,
 						markCssAssetProcessed,
@@ -1946,6 +3242,46 @@ function createViteCssFinalizerOutputPlugin(context) {
 						debug,
 						onUpdate: opts.onUpdate
 					});
+				};
+				collectViteProcessedCssAssets();
+				const createHarmonyBundleStyleSources = async (runtime) => {
+					const cssSources = collectViteProcessedCssSources(getViteProcessedCssAssetResults);
+					const applyUtilities = collectUniAppXHarmonyApplyUtilities(bundle);
+					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({
+						opts,
+						runtimeState,
+						runtime: harmonyRuntime,
+						rawSource: createUniAppXHarmonyApplyGeneratorSource(applyStyleSources, applyUtilities),
+						file: "uni-app-x-harmony-apply.css",
+						cssHandlerOptions: harmonyCssHandlerOptions,
+						cssUserHandlerOptions: {
+							...harmonyCssHandlerOptions,
+							isMainChunk: false
+						},
+						getSourceCandidatesForEntries,
+						styleHandler: opts.styleHandler,
+						debug
+					});
+					if (generated?.css) cssSources.push(annotateCss(generated.css));
+					return cssSources;
+				};
+				const injectHarmonyBundleStyles = async (runtime) => {
+					if (!isHarmonyAppStyleTarget) return;
+					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 entries = Object.entries(bundle).filter(isCssOutputAssetEntry);
+				if (entries.length === 0) {
+					await injectHarmonyBundleStyles(getRecordedGeneratorCandidates?.() ?? getSourceCandidates?.() ?? await ensureRuntimeClassSet());
+					collectViteProcessedCssAssets();
+					injectViteProcessedCssIntoMainCss();
 					return;
 				}
 				await runtimeState.readyPromise;
@@ -1957,7 +3293,7 @@ function createViteCssFinalizerOutputPlugin(context) {
 					const file = output.fileName || bundleFile;
 					const rawSource = output.source.toString();
 					if (isViteProcessedCssAsset?.(output, file)) {
-						const nextCss = stripBundlerGeneratedCssMarkers(rawSource);
+						const nextCss = annotateCss(stripBundlerGeneratedCssMarkers(rawSource));
 						output.source = nextCss;
 						markCssAssetProcessed(output, file);
 						recordCssAssetResult?.(file, nextCss);
@@ -1990,7 +3326,7 @@ function createViteCssFinalizerOutputPlugin(context) {
 						styleHandler: opts.styleHandler,
 						debug
 					}) : void 0;
-					const nextCss = generated?.css ?? (generatorOptions.target === "web" ? rawSource : (await opts.styleHandler(rawSource, cssHandlerOptions)).css);
+					const nextCss = annotateCss(generated?.css ?? (generatorOptions.target === "web" ? rawSource : (await opts.styleHandler(rawSource, cssHandlerOptions)).css));
 					if (generated) {
 						registerGeneratorDependencies(this, generated.dependencies);
 						debug("css finalizer generated result: %s bytes=%d", file, nextCss.length);
@@ -2002,14 +3338,9 @@ function createViteCssFinalizerOutputPlugin(context) {
 					opts.onUpdate(file, rawSource, nextCss);
 					debug("css finalizer handle: %s", file);
 				}));
-				injectViteProcessedCssIntoMainCssAssets(bundle, {
-					opts,
-					getViteProcessedCssAssetResults,
-					markCssAssetProcessed,
-					recordCssAssetResult,
-					debug,
-					onUpdate: opts.onUpdate
-				});
+				await injectHarmonyBundleStyles(generatorRuntime);
+				collectViteProcessedCssAssets();
+				injectViteProcessedCssIntoMainCss();
 			}
 		}
 	};
@@ -2261,8 +3592,14 @@ function createViteRuntimeClassSet(options) {
 		readyPromise: createTailwindRuntimeReadyPromise(initialTwPatcher),
 		refreshTailwindcssPatcher
 	};
-	const bundleRuntimeClassSetManager = createBundleRuntimeClassSetManager({ bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues });
-	const transformRuntimeClassSetManager = createBundleRuntimeClassSetManager({ bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues });
+	const bundleRuntimeClassSetManager = createBundleRuntimeClassSetManager({
+		bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues,
+		escapeMap: opts.escapeMap
+	});
+	const transformRuntimeClassSetManager = createBundleRuntimeClassSetManager({
+		bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues,
+		escapeMap: opts.escapeMap
+	});
 	let runtimeSet;
 	let runtimeSetPromise;
 	let runtimeRefreshSignature;
@@ -2490,6 +3827,7 @@ const weappTailwindcssPackageDir = resolvePackageDir("weapp-tailwindcss");
 const weappTailwindcssDirPosix = slash(weappTailwindcssPackageDir);
 const sourceCandidateScanSnapshotCache = /* @__PURE__ */ new Map();
 const SFC_STYLE_BLOCK_RE = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+const SFC_COMPONENT_FILE_RE = /\.(?:vue|uvue|nvue|svelte|mpx)$/i;
 function normalizeSignaturePath(value) {
 	return slash(path.resolve(value));
 }
@@ -2521,6 +3859,10 @@ function stripSourceHash(sourceFile) {
 	const hashIndex = sourceFile.indexOf("#");
 	return hashIndex === -1 ? sourceFile : sourceFile.slice(0, hashIndex);
 }
+function isMainStyleEntryFile(file) {
+	const name = path.basename(stripRequestQuery(cleanUrl(file))).replace(/\.[^.]+$/, "");
+	return name === "app" || name === "main";
+}
 function normalizeCssSourceIdentity(sourceFile) {
 	const cleanSourceFile = stripSourceHash(sourceFile);
 	const { filename, query } = parseVueRequest(cleanSourceFile);
@@ -2639,6 +3981,7 @@ function WeappTailwindcss(options = {}) {
 	const viteProcessedCssAssetResults = /* @__PURE__ */ new Map();
 	const rememberedCssSources = /* @__PURE__ */ new Map();
 	const rememberedCssSignatureByFile = /* @__PURE__ */ new Map();
+	const knownSfcSources = /* @__PURE__ */ new Map();
 	const tailwindRootCssModuleIds = /* @__PURE__ */ new Set();
 	const { runtimeState, refreshRuntimeState, ensureRuntimeClassSet, ensureBundleRuntimeClassSet } = createViteRuntimeClassSet({
 		opts,
@@ -2672,6 +4015,7 @@ function WeappTailwindcss(options = {}) {
 	};
 	const getSourceCandidates = () => sourceCandidateCollector.values();
 	const getSourceCandidatesForEntries = (entries) => sourceCandidateCollector.valuesForEntries(entries);
+	const getSourceCandidateSourcesForEntries = (entries, options) => sourceCandidateCollector.sourcesForEntries(entries, options);
 	const isWatchBuild = () => resolvedConfig?.command === "build" && resolvedConfig.build.watch != null;
 	const isWatchLikeBuild = () => isWatchBuild() || resolvedConfig?.command === "serve" || process$1.env["WEAPP_TW_WATCH_REGRESSION"] === "1" || process$1.env["WEAPP_TW_HMR_TIMING"] === "1";
 	const hasSourceCandidateScanState = () => sourceCandidateScanSignature !== void 0;
@@ -2779,19 +4123,18 @@ function WeappTailwindcss(options = {}) {
 	const syncChangedSourceCandidateFile = (id) => {
 		if (!shouldOwnTailwindGeneration || !isSourceCandidateRequest(id)) return Promise.resolve();
 		const file = cleanUrl(id);
-		const refreshRememberedCssSourceTask = refreshRememberedCssSourceByCurrentFile(file);
 		if (isSourceScanDependency(file)) invalidateSourceCandidateScan();
 		if (sourceScanMatcher && !sourceScanMatcher(file)) {
 			sourceCandidateCollector.remove(file);
 			cacheCurrentSourceCandidateScan();
-			return refreshRememberedCssSourceTask;
+			return refreshRememberedCssSourceByCurrentFile(file);
 		}
 		if (sourceScanExplicit && sourceScanEntries?.length === 0) {
 			cacheCurrentSourceCandidateScan();
-			return refreshRememberedCssSourceTask;
+			return refreshRememberedCssSourceByCurrentFile(file);
 		}
 		const existingTask = pendingSourceCandidateSyncByFile.get(file);
-		if (existingTask) return Promise.all([refreshRememberedCssSourceTask, existingTask]).then(() => void 0);
+		if (existingTask) return existingTask.then(() => refreshRememberedCssSourceByCurrentFile(file)).then(() => void 0);
 		const task = sourceCandidateCollector.syncCurrentFile(id).catch((error) => {
 			debug("source candidate watch sync failed: %s %O", id, error);
 		}).then(() => {
@@ -2802,18 +4145,37 @@ function WeappTailwindcss(options = {}) {
 		});
 		pendingSourceCandidateSyncs.add(task);
 		pendingSourceCandidateSyncByFile.set(file, task);
-		return Promise.all([refreshRememberedCssSourceTask, task]).then(() => void 0);
+		return task.then(() => refreshRememberedCssSourceByCurrentFile(file)).then(() => void 0);
 	};
 	const shouldCollectTransformedSourceCandidates = (id) => {
 		if (id.search(/[?#]/) < 0) return true;
 		const file = cleanUrl(id);
-		return !/\.(?:vue|uvue|nvue|svelte|mpx)$/i.test(file);
+		return !SFC_COMPONENT_FILE_RE.test(file);
+	};
+	const hasSfcStyleBlocks = (source) => {
+		SFC_STYLE_BLOCK_RE.lastIndex = 0;
+		return SFC_STYLE_BLOCK_RE.test(source);
+	};
+	const normalizeKnownSfcSourceKey = (file) => normalizeOutputPathKey(path.resolve(cleanUrl(file)));
+	const rememberKnownSfcSource = (id, code) => {
+		if (id.search(/[?#]/) >= 0) return;
+		const file = cleanUrl(id);
+		if (!SFC_COMPONENT_FILE_RE.test(file)) return;
+		if (!hasSfcStyleBlocks(code)) return;
+		knownSfcSources.set(normalizeKnownSfcSourceKey(file), code);
+	};
+	const getKnownSfcSource = (file) => {
+		const scanSource = sourceCandidateCollector.source(file);
+		if (scanSource && hasSfcStyleBlocks(scanSource)) return scanSource;
+		return knownSfcSources.get(normalizeKnownSfcSourceKey(file));
 	};
 	const rememberCssSource = (entry, cssRuntimeSignature) => {
-		const key = normalizeOutputPathKey(entry.outputFile);
+		const outputKey = normalizeOutputPathKey(entry.outputFile);
+		const normalizedSourceFile = normalizeCssSourceIdentity(entry.sourceFile);
+		const previousOutputEntry = rememberedCssSources.get(outputKey);
+		const key = previousOutputEntry != null && normalizeCssSourceIdentity(previousOutputEntry.sourceFile) !== normalizedSourceFile ? `${outputKey}\0${normalizedSourceFile}` : outputKey;
 		const previous = rememberedCssSources.get(key);
 		rememberedCssSources.set(key, entry);
-		const normalizedSourceFile = normalizeCssSourceIdentity(entry.sourceFile);
 		for (const [rememberedKey, remembered] of rememberedCssSources) {
 			if (rememberedKey === key || normalizeCssSourceIdentity(remembered.sourceFile) !== normalizedSourceFile) continue;
 			rememberedCssSources.set(rememberedKey, {
@@ -2855,41 +4217,57 @@ function WeappTailwindcss(options = {}) {
 			match = SFC_STYLE_BLOCK_RE.exec(source);
 		}
 	};
+	const extractSfcStyleSource = (source, index) => {
+		if (index !== void 0) return extractSfcStyleBlock(source, index);
+		const styleSources = [];
+		SFC_STYLE_BLOCK_RE.lastIndex = 0;
+		let match = SFC_STYLE_BLOCK_RE.exec(source);
+		while (match !== null) {
+			styleSources.push(match[1] ?? "");
+			match = SFC_STYLE_BLOCK_RE.exec(source);
+		}
+		return styleSources.length > 0 ? styleSources.join("\n") : void 0;
+	};
+	const resolveCachedStyleSource = (sourceFile) => {
+		const file = cleanUrl(stripRequestQuery(sourceFile));
+		if (SFC_COMPONENT_FILE_RE.test(file)) return getKnownSfcSource(file);
+		if (isSourceStyleRequest(file)) return sourceCandidateCollector.source(file);
+	};
 	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;
-		try {
-			const source = await readFile(file, "utf8");
-			if (/\.(?:vue|uvue|nvue|svelte|mpx)$/i.test(file)) {
-				for (const remembered of matchedRememberedSources) {
-					const { query } = parseVueRequest(remembered.sourceFile);
-					const styleSource = extractSfcStyleBlock(source, query.type === "style" ? query.index : void 0);
-					if (styleSource !== void 0) refreshRememberedCssSourceBySourceFile(remembered.sourceFile, styleSource);
-				}
-				return;
+		const source = resolveCachedStyleSource(file);
+		if (source == null) {
+			debug("refresh remembered css source skipped: missing cached source for %s", file);
+			return;
+		}
+		if (SFC_COMPONENT_FILE_RE.test(file)) {
+			for (const remembered of matchedRememberedSources) {
+				const { query } = parseVueRequest(remembered.sourceFile);
+				const styleSource = extractSfcStyleSource(source, query.type === "style" ? query.index : void 0);
+				if (styleSource !== void 0) refreshRememberedCssSourceBySourceFile(remembered.sourceFile, styleSource);
 			}
-			if (isSourceStyleRequest(file)) refreshRememberedCssSourceBySourceFile(file, source);
-		} catch (error) {
-			debug("refresh remembered css source failed: %s %O", file, error);
+			return;
 		}
+		if (isSourceStyleRequest(file)) refreshRememberedCssSourceBySourceFile(file, source);
 	};
 	const refreshRememberedCssSource = async (remembered) => {
 		const file = cleanUrl(stripRequestQuery(remembered.sourceFile));
 		const rememberedKey = [...rememberedCssSources.entries()].find(([, entry]) => entry === remembered)?.[0];
 		if (!rememberedKey || !path.isAbsolute(file)) return;
-		try {
-			const source = await readFile(file, "utf8");
-			if (/\.(?:vue|uvue|nvue|svelte|mpx)$/i.test(file)) {
-				const { query } = parseVueRequest(remembered.sourceFile);
-				const styleSource = extractSfcStyleBlock(source, query.type === "style" ? query.index : void 0);
-				return styleSource === void 0 ? void 0 : refreshRememberedCssSourceEntry(rememberedKey, remembered, remembered.sourceFile, styleSource);
-			}
-			if (isSourceStyleRequest(file)) return refreshRememberedCssSourceEntry(rememberedKey, remembered, remembered.sourceFile, source);
-		} catch (error) {
-			debug("refresh remembered css source before bundle replay failed: %s %O", file, error);
+		const source = resolveCachedStyleSource(file);
+		if (source == null) {
+			debug("refresh remembered css source before bundle replay skipped: missing cached source for %s", file);
+			return;
 		}
+		if (SFC_COMPONENT_FILE_RE.test(file)) {
+			const { query } = parseVueRequest(remembered.sourceFile);
+			const styleSource = extractSfcStyleSource(source, query.type === "style" ? query.index : void 0);
+			return styleSource === void 0 ? void 0 : refreshRememberedCssSourceEntry(rememberedKey, remembered, remembered.sourceFile, styleSource);
+		}
+		if (isSourceStyleRequest(file)) return refreshRememberedCssSourceEntry(rememberedKey, remembered, remembered.sourceFile, source);
 	};
 	const getRememberedCssSources = () => rememberedCssSources;
 	const getRememberedCssSourceEntry = (file) => rememberedCssSources.get(normalizeOutputPathKey(file));
@@ -2901,9 +4279,12 @@ function WeappTailwindcss(options = {}) {
 		viteGeneratedCssByFile.set(file, css);
 	};
 	const recordViteProcessedCssAssetResult = (file, css, options = {}) => {
-		viteProcessedCssAssetResults.set(normalizeOutputPathKey(file), {
+		const key = normalizeOutputPathKey(file);
+		const previous = viteProcessedCssAssetResults.get(key);
+		viteProcessedCssAssetResults.set(key, {
 			css,
-			injectIntoMain: options.injectIntoMain
+			injectIntoMain: options.injectIntoMain ?? previous?.injectIntoMain,
+			outputFile: options.outputFile ?? previous?.outputFile
 		});
 	};
 	const getViteProcessedCssAssetResults = () => viteProcessedCssAssetResults.entries();
@@ -2958,6 +4339,10 @@ function WeappTailwindcss(options = {}) {
 	const isUniViteProject = () => {
 		return resolvedConfig?.plugins?.some((plugin) => plugin.name.includes("uni")) ?? false;
 	};
+	const isHarmonyAppBuildTarget = () => {
+		if (resolveUniUtsPlatform().isAppHarmony) return true;
+		return isUniAppXHarmonyOutDir(resolvedConfig?.build?.outDir);
+	};
 	const sendSupplementalCssHotUpdates = (ctx, cssModules) => {
 		const updates = cssModules.filter((mod) => !includesHotModule(ctx.modules, mod)).map((mod) => {
 			const hotUrl = resolveModuleHotUrl(mod);
@@ -3011,10 +4396,16 @@ function WeappTailwindcss(options = {}) {
 		await waitForSourceCandidateSyncs();
 		const file = cleanUrl(id);
 		const rootDir = resolvedConfig?.root ? path.resolve(resolvedConfig.root) : process$1.cwd();
-		const isNativeAppStyleTarget = resolveUniUtsPlatform().isApp;
+		const isHarmonyAppStyleTarget = isHarmonyAppBuildTarget();
+		const isNativeAppStyleTarget = resolveUniUtsPlatform().isApp || isHarmonyAppStyleTarget;
 		const outputFile = resolveViteCssPipelineOutputFile(file, opts, rootDir, generatorOptions.target === "web", isNativeAppStyleTarget);
 		const runtime = getRecordedGeneratorCandidates() ?? getSourceCandidates() ?? await ensureRuntimeClassSet();
-		const cssHandlerOptions = transformCssHandlerOptions.getCssHandlerOptions(outputFile);
+		const outputCssHandlerOptions = transformCssHandlerOptions.getCssHandlerOptions(outputFile);
+		const cssHandlerOptions = {
+			...transformCssHandlerOptions.getCssHandlerOptions(file),
+			isMainChunk: outputCssHandlerOptions.isMainChunk || isMainStyleEntryFile(file)
+		};
+		const shouldDeferEmptyScopedCssSource = !(opts.appType === "uni-app-x" && !cssHandlerOptions.isMainChunk && hasTailwindApplyDirective(code));
 		const generated = await generateCssByGenerator({
 			opts,
 			runtimeState,
@@ -3022,21 +4413,33 @@ function WeappTailwindcss(options = {}) {
 			rawSource: code,
 			file,
 			cssHandlerOptions,
-			cssUserHandlerOptions: transformCssHandlerOptions.getCssUserHandlerOptions(outputFile),
+			cssUserHandlerOptions: transformCssHandlerOptions.getCssUserHandlerOptions(file),
 			getSourceCandidatesForEntries,
 			styleHandler,
 			debug,
 			previousCss: viteGeneratedCssByFile.get(file),
-			deferEmptyScopedCssSource: true
+			deferEmptyScopedCssSource: shouldDeferEmptyScopedCssSource
 		});
 		if (!generated) return;
+		const tracedCss = annotateCssSourceTrace(generated.css, {
+			opts,
+			tokenSources: createCssTokenSourceMap(getSourceCandidateSourcesForEntries(void 0), opts)
+		});
 		for (const dependency of generated.dependencies) hookContext?.addWatchFile?.(dependency);
-		viteGeneratedCssByFile.set(file, generated.css);
-		if (generated.css.includes("weapp-tailwindcss layer components start")) recordViteProcessedCssAssetResult(file, generated.css, { injectIntoMain: cssHandlerOptions.isMainChunk });
+		viteGeneratedCssByFile.set(file, tracedCss);
+		const shouldInjectGeneratedCssIntoMain = isMainStyleEntryFile(file) || mainCssChunkMatcher(outputFile, opts.appType);
+		recordViteProcessedCssAssetResult(file, tracedCss, {
+			injectIntoMain: shouldInjectGeneratedCssIntoMain,
+			outputFile
+		});
+		if (tracedCss.includes("weapp-tailwindcss layer components start")) recordViteProcessedCssAssetResult(file, tracedCss, {
+			injectIntoMain: shouldInjectGeneratedCssIntoMain,
+			outputFile
+		});
 		if (isNativeAppStyleTarget && outputFile.endsWith(".css")) hookContext?.emitFile?.({
 			type: "asset",
 			fileName: outputFile,
-			source: generated.css
+			source: tracedCss
 		});
 		markViteProcessedCssSource(file);
 		rememberTailwindRootCssModule(id);
@@ -3046,8 +4449,8 @@ function WeappTailwindcss(options = {}) {
 			rawSource: code,
 			sourceFile: id
 		});
-		debug("css generated for vite postcss pipeline: %s bytes=%d", file, generated.css.length);
-		return `${createBundlerGeneratedCssMarker("vite", normalizeViteProcessedCssFile(file))}\n${generated.css}`;
+		debug("css generated for vite postcss pipeline: %s bytes=%d", file, tracedCss.length);
+		return `${createBundlerGeneratedCssMarker("vite", normalizeViteProcessedCssFile(file))}\n${tracedCss}`;
 	};
 	const rewritePlugins = createRewriteCssImportsPlugins({
 		getAppType: () => opts.appType,
@@ -3077,12 +4480,14 @@ function WeappTailwindcss(options = {}) {
 		getViteProcessedCssAssetResult,
 		getSourceCandidates,
 		getSourceCandidatesForEntries,
+		getSourceCandidateSourcesForEntries,
 		waitForSourceCandidateSyncs,
 		rememberCssSource,
 		refreshRememberedCssSource,
 		getRememberedCssSources,
 		getRememberedCssSignature,
 		setRememberedCssSignature,
+		getKnownSfcSource,
 		recordGeneratorCandidates,
 		hmrTimingRecorder
 	});
@@ -3101,6 +4506,7 @@ function WeappTailwindcss(options = {}) {
 		getRecordedGeneratorCandidates,
 		getSourceCandidates,
 		getSourceCandidatesForEntries,
+		getSourceCandidateSourcesForEntries,
 		waitForSourceCandidateSyncs,
 		rememberMainCssSource: (file, rawSource) => rememberCssSource({
 			outputFile: file,
@@ -3134,6 +4540,7 @@ function WeappTailwindcss(options = {}) {
 			name: `${vitePluginName}:source-candidates`,
 			enforce: "pre",
 			async transform(code, id) {
+				if (shouldOwnTailwindGeneration) rememberKnownSfcSource(id, code);
 				if (!shouldOwnTailwindGeneration || !isSourceCandidateRequest(id) || !shouldCollectTransformedSourceCandidates(id)) return;
 				return hmrTimingRecorder.measure("sourceCandidates.transform", async () => {
 					invalidateRecordedGeneratorCandidates();
@@ -3259,11 +4666,14 @@ function WeappTailwindcss(options = {}) {
 					}
 				}, { emit: false });
 			},
-			generateBundle: generateBundleHook
-		},
-		cssFinalizerOutputPlugin
+			generateBundle: {
+				order: "post",
+				handler: generateBundleHook
+			}
+		}
 	];
 	if (uniAppXPlugins) plugins.push(...uniAppXPlugins);
+	plugins.push(cssFinalizerOutputPlugin);
 	return plugins;
 }
 //#endregion