tw-migrate 0.3.0 → 0.5.0

package/dist/index.js

@@ -3,8 +3,8 @@ import { promisify } from "node:util";
 import { chmod, lstat, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { execFile } from "node:child_process";
-import { parse } from "parse5";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { parse } from "parse5";
 //#region src/util/diff.ts
 function unifiedDiff(path, before, after) {
 	const oldLines = before.split("\n");
@@ -18,186 +18,10 @@ function unifiedDiff(path, before, after) {
 	].join("");
 }
 //#endregion
-//#region src/parser/html.ts
-const RECOVERABLE_PARSE_ERRORS = /* @__PURE__ */ new Set(["missing-doctype"]);
-const TEMPLATE_MARKERS = /\{\{|\}\}|\$\{|<%|%>|<#|#>|\[%|%\]/;
-function parseHtmlSource(path, source) {
-	const errors = [];
-	const document = parse(source, {
-		sourceCodeLocationInfo: true,
-		onParseError(error) {
-			if (!RECOVERABLE_PARSE_ERRORS.has(error.code)) errors.push(error);
-		}
-	});
-	if (errors.length > 0) throw new Error(`Failed to parse ${path}: ${errors.map((error) => error.code).join(", ")}`);
-	const links = [];
-	const bases = [];
-	const elements = [];
-	const dynamicAttributes = [];
-	const scriptTexts = [];
-	const unquoted = (attribute) => source[attribute.start - 1] !== "\"" && source[attribute.start - 1] !== "'";
-	function visit(node) {
-		if (node.tagName === "script") {
-			for (const child of node.childNodes ?? []) if (child.nodeName === "#text" && child.value) scriptTexts.push(child.value);
-		}
-		if (node.tagName) {
-			const attributes = new Map((node.attrs ?? []).map((attribute) => [attribute.name, attribute.value]));
-			const locations = node.sourceCodeLocation?.attrs;
-			if (locations) {
-				if (node.tagName === "link" && stylesheetRel(attributes.get("rel")) && !attributes.has("disabled")) {
-					const href = locatedAttribute(source, locations.href, attributes.get("href"));
-					const media = locatedAttribute(source, locations.media, attributes.get("media"));
-					const tag = node.sourceCodeLocation?.startTag ?? node.sourceCodeLocation;
-					if (href && tag) links.push({
-						href: href.value,
-						media: media?.value ?? "",
-						start: href.start,
-						end: href.end,
-						tagStart: tag.startOffset,
-						tagEnd: tag.endOffset
-					});
-				}
-				if (node.tagName === "base" && bases.length === 0) {
-					const href = locatedAttribute(source, locations.href, attributes.get("href"));
-					if (href) bases.push({
-						href: href.value,
-						writable: href.writable,
-						start: href.start,
-						end: href.end
-					});
-				}
-				let classAttribute = locatedAttribute(source, locations.class, attributes.get("class"));
-				const idAttribute = locatedAttribute(source, locations.id, attributes.get("id"));
-				const dynamic = (!classAttribute && idAttribute && locations.class ? {
-					start: locations.class.startOffset,
-					end: locations.class.endOffset
-				} : void 0) ?? [classAttribute, idAttribute].find((attribute) => attribute && (!attribute.writable || TEMPLATE_MARKERS.test(attribute.value))) ?? (classAttribute && unquoted(classAttribute) ? classAttribute : void 0);
-				if (dynamic) dynamicAttributes.push({
-					start: dynamic.start,
-					end: dynamic.end
-				});
-				else if (classAttribute || idAttribute) {
-					if (!classAttribute && idAttribute) {
-						const insertion = classInsertionOffset$1(source, node.sourceCodeLocation?.startTag);
-						if (insertion !== void 0) classAttribute = {
-							value: "",
-							start: insertion,
-							end: insertion,
-							synthetic: true
-						};
-					}
-					elements.push({
-						classAttribute,
-						idAttribute
-					});
-				}
-			}
-		}
-		for (const child of node.childNodes ?? []) visit(child);
-		if (node.content) visit(node.content);
-	}
-	visit(document);
-	return {
-		...toByteOffsets(source, {
-			links,
-			bases,
-			elements,
-			dynamicAttributes
-		}),
-		scriptText: scriptTexts.join("\n")
-	};
-}
-function utf8OffsetMap(source, indices) {
-	const sorted = [...new Set(indices)].sort((left, right) => left - right);
-	const map = /* @__PURE__ */ new Map();
-	let lastIndex = 0;
-	let bytes = 0;
-	for (const index of sorted) {
-		bytes += Buffer.byteLength(source.slice(lastIndex, index));
-		lastIndex = index;
-		map.set(index, bytes);
-	}
-	return map;
-}
-function offsetLookup(offsets) {
-	return (index) => {
-		const byte = offsets.get(index);
-		if (byte === void 0) throw new Error(`No byte offset was mapped for index ${index}`);
-		return byte;
-	};
-}
-function toByteOffsets(source, parsed) {
-	const offset = offsetLookup(utf8OffsetMap(source, [
-		...parsed.links.flatMap((link) => [
-			link.start,
-			link.end,
-			link.tagStart,
-			link.tagEnd
-		]),
-		...parsed.bases.flatMap((base) => [base.start, base.end]),
-		...parsed.elements.flatMap((element) => [element.classAttribute, element.idAttribute].flatMap((value) => value ? [value.start, value.end] : [])),
-		...parsed.dynamicAttributes.flatMap((value) => [value.start, value.end])
-	]));
-	const attribute = (value) => ({
-		...value,
-		start: offset(value.start),
-		end: offset(value.end)
-	});
-	return {
-		links: parsed.links.map((link) => ({
-			...link,
-			start: offset(link.start),
-			end: offset(link.end),
-			tagStart: offset(link.tagStart),
-			tagEnd: offset(link.tagEnd)
-		})),
-		bases: parsed.bases.map((base) => attribute(base)),
-		elements: parsed.elements.map((element) => ({
-			classAttribute: element.classAttribute && attribute(element.classAttribute),
-			idAttribute: element.idAttribute && attribute(element.idAttribute)
-		})),
-		dynamicAttributes: parsed.dynamicAttributes.map((value) => attribute(value))
-	};
-}
-function classInsertionOffset$1(source, startTag) {
-	if (!startTag) return void 0;
-	let offset = startTag.endOffset - 1;
-	if (source[offset] !== ">") return void 0;
-	while (offset > startTag.startOffset && /\s/.test(source[offset - 1] ?? "")) offset -= 1;
-	if (source[offset - 1] === "/") offset -= 1;
-	return offset;
-}
-function stylesheetRel(value = "") {
-	const tokens = value.toLowerCase().split(/\s+/);
-	return tokens.includes("stylesheet") && !tokens.includes("alternate");
-}
-function locatedAttribute(source, location, parsedValue) {
-	if (!location || parsedValue === void 0) return void 0;
-	const raw = source.slice(location.startOffset, location.endOffset);
-	const equals = raw.indexOf("=");
-	if (equals < 0) return void 0;
-	let start = equals + 1;
-	while (/\s/.test(raw[start] ?? "")) start += 1;
-	const quote = raw[start];
-	let end;
-	if (quote === "\"" || quote === "'") {
-		start += 1;
-		end = raw.lastIndexOf(quote);
-		if (end < start) return void 0;
-	} else {
-		end = start;
-		while (end < raw.length && !/\s/.test(raw[end] ?? "")) end += 1;
-	}
-	const value = raw.slice(start, end);
-	return {
-		value: value.includes("&") ? parsedValue : value,
-		writable: !value.includes("&"),
-		start: location.startOffset + start,
-		end: location.startOffset + end
-	};
-}
-//#endregion
 //#region src/native.ts
+function errorCode(error) {
+	return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
 const require = createRequire(import.meta.url);
 const target = {
 	"darwin-arm64": "darwin-arm64",
@@ -219,7 +43,75 @@ try {
 		throw new Error(`No tw-migrate native addon was found for ${target}. Reinstall the package or build it locally.`);
 	}
 }
-const { decodeSourceMap, planBatchMigration, staticImportBindings, staticImports, staticStringExpression, validateCss } = binding;
+const { collectMediaConditions, mediaProbeKey, decodeSourceMap, planBatchMigration, validateCss } = binding;
+function object(value) {
+	return value !== null && typeof value === "object";
+}
+function decode(label, json, valid) {
+	const value = JSON.parse(json);
+	if (!valid(value)) throw new Error(`Invalid native ${label} result`);
+	return value;
+}
+function cssDirectives$1(source) {
+	try {
+		const value = JSON.parse(binding.collectCssDirectives(source));
+		return Array.isArray(value) ? value : null;
+	} catch {
+		return null;
+	}
+}
+function sourceImport(value) {
+	return object(value) && typeof value.specifier === "string" && typeof value.typeOnly === "boolean" && typeof value.dynamic === "boolean";
+}
+function sourceAnalysisResult(value) {
+	return object(value) && Array.isArray(value.imports) && value.imports.every(sourceImport) && Array.isArray(value.staticImports) && value.staticImports.every((item) => typeof item === "string") && Array.isArray(value.defaultImports) && value.defaultImports.every((item) => object(item) && typeof item.source === "string" && typeof item.local === "string") && Array.isArray(value.vueGlobPatterns) && value.vueGlobPatterns.every((item) => typeof item === "string") && Array.isArray(value.useCssModuleLocals) && value.useCssModuleLocals.every((item) => typeof item === "string") && Array.isArray(value.unboundReferences) && value.unboundReferences.every((item) => typeof item === "string") && [
+		value.vueGlobUnverifiable,
+		value.hasDynamicImport,
+		value.hasVueFallthroughMacro,
+		value.usesCssModule,
+		value.hasUnboundUseCssModule,
+		value.definesRootUseCssModule
+	].every((item) => typeof item === "boolean");
+}
+const ANALYSIS_CACHE_LIMIT = 4096;
+const sourceAnalysisCache = /* @__PURE__ */ new Map();
+const stylesheetAnalysisCache = /* @__PURE__ */ new Map();
+function bound(cache) {
+	while (cache.size > ANALYSIS_CACHE_LIMIT) {
+		const oldest = cache.keys().next().value;
+		if (oldest === void 0) break;
+		cache.delete(oldest);
+	}
+}
+function expressionAnalysis(path, source) {
+	return decode("expression analysis", binding.expressionAnalysis(path, source), (value) => object(value) && (typeof value.staticString === "string" || value.staticString === null) && (typeof value.vueModuleMember === "string" || value.vueModuleMember === null) && typeof value.usesCssModule === "boolean" && typeof value.referencesUseCssModule === "boolean" && Array.isArray(value.references) && value.references.every((item) => typeof item === "string"));
+}
+function sourceAnalysis(path, source) {
+	const cached = sourceAnalysisCache.get(path);
+	if (cached?.source === source) return cached.analysis;
+	const analysis = decode("source analysis", binding.sourceAnalysis(path, source), sourceAnalysisResult);
+	sourceAnalysisCache.set(path, {
+		source,
+		analysis
+	});
+	bound(sourceAnalysisCache);
+	return analysis;
+}
+function stylesheetAnalysis(path, source) {
+	const cached = stylesheetAnalysisCache.get(path);
+	if (cached?.source === source) return cached.analysis;
+	const analysis = decode("stylesheet analysis", binding.stylesheetAnalysis(path, source), (value) => object(value) && Array.isArray(value.references) && value.references.every((item) => typeof item === "string") && Array.isArray(value.imports) && value.imports.every((item) => object(item) && typeof item.href === "string" && typeof item.media === "string" && typeof item.start === "number" && typeof item.end === "number") && [
+		value.unverifiable,
+		value.scopeEscapesUnverifiable,
+		value.selectorsUnverifiable
+	].every((item) => typeof item === "boolean") && Array.isArray(value.scopeEscapes) && value.scopeEscapes.every((item) => typeof item === "string") && Array.isArray(value.scopeShadowCss) && value.scopeShadowCss.every((item) => typeof item === "string") && object(value.themeTokens) && Object.values(value.themeTokens).every((item) => typeof item === "string") && Array.isArray(value.globalAtRuleIdentities) && value.globalAtRuleIdentities.every((item) => typeof item === "string") && typeof value.globalAtRulesUnverifiable === "boolean");
+	stylesheetAnalysisCache.set(path, {
+		source,
+		analysis
+	});
+	bound(stylesheetAnalysisCache);
+	return analysis;
+}
 //#endregion
 //#region src/parser/style-compiler.ts
 const SASS_EXTENSIONS = /* @__PURE__ */ new Set([".scss", ".sass"]);
@@ -240,11 +132,13 @@ async function loadProjectModule(packageRoot, name, errorMessage) {
 	const imported = await import(pathToFileURL(modulePath).href);
 	return imported.default ?? imported;
 }
+const missingCompilerMessage = (name) => `${name} must be installed in the target project.`;
+const MISSING_STYLE_COMPILER_MESSAGES = /* @__PURE__ */ new Set([missingCompilerMessage("Sass"), missingCompilerMessage("Less")]);
 function loadProjectSass(packageRoot) {
-	return loadProjectModule(packageRoot, "sass", "Sass must be installed in the target project.");
+	return loadProjectModule(packageRoot, "sass", missingCompilerMessage("Sass"));
 }
 function loadProjectLess(packageRoot) {
-	return loadProjectModule(packageRoot, "less", "Less must be installed in the target project.");
+	return loadProjectModule(packageRoot, "less", missingCompilerMessage("Less"));
 }
 async function compileStyleEntry(compilers, packageRoot, entryPath, source, options = {}) {
 	if (isSassPath(entryPath)) return compileSassEntry(compilers.sass ??= await loadProjectSass(packageRoot), entryPath, source, options);
@@ -353,8 +247,8 @@ const IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
 	"node_modules"
 ]);
 const RECOVERABLE_INPUT_ERROR = "TW_MIGRATE_RECOVERABLE_INPUT:";
-function errorCode(error) {
-	return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
 }
 function isWithin(root, path) {
 	return path === root || path.startsWith(`${root}${sep}`);
@@ -369,15 +263,6 @@ function isStylesheetModule(path) {
 	const syntax = stylesheetSyntax(path);
 	return syntax !== void 0 && path.endsWith(`.module.${syntax}`);
 }
-function sourceReferencesStyle(file, stylePath) {
-	let importPath = normalizedRelativePath(dirname(file.path), stylePath);
-	if (!importPath.startsWith(".")) importPath = `./${importPath}`;
-	return [
-		`'${importPath}'`,
-		`"${importPath}"`,
-		`\`${importPath}\``
-	].some((literal) => file.source.includes(literal));
-}
 function isProjectInput(workspaceRoot, path) {
 	return isWithin(workspaceRoot, path) && !relative(workspaceRoot, path).split(/[\\/]/).includes("node_modules");
 }
@@ -404,43 +289,44 @@ function recordSnapshot(snapshots, path, source) {
 	return source;
 }
 function packageFailure(workspaceRoot, packageRoot, error) {
-	const message = error instanceof Error ? error.message : String(error);
+	const message = errorMessage(error);
 	return {
 		package: normalizedRelativePath(workspaceRoot, packageRoot) || ".",
 		message: message.startsWith("TW_MIGRATE_RECOVERABLE_INPUT:") ? message.slice(29) : message
 	};
 }
 function isRecoverablePlanningError(error) {
-	return (error instanceof Error ? error.message : String(error)).startsWith(RECOVERABLE_INPUT_ERROR);
+	return errorMessage(error).startsWith(RECOVERABLE_INPUT_ERROR);
 }
 function isMissingStyleCompilerError(error) {
-	const message = error instanceof Error ? error.message : String(error);
-	return /^(?:Sass|Less) must be installed in the target project\.$/.test(message);
+	return MISSING_STYLE_COMPILER_MESSAGES.has(errorMessage(error));
 }
 function isIntegrityError(error) {
-	return (error instanceof Error ? error.message : String(error)).startsWith("Source changed during planning:");
+	return errorMessage(error).startsWith("Source changed during planning:");
 }
 function normalizedRelativePath(root, path) {
 	return relative(root, path).split(sep).join("/");
 }
-function maskCssComments(source) {
-	return source.replace(/\/\*[\s\S]*?\*\//g, (comment) => comment.replace(/[^\r\n]/g, " "));
-}
 function indexStylesheetDependents(styleSources) {
 	const dependents = /* @__PURE__ */ new Map();
-	for (const [path, rawSource] of styleSources) {
-		const source = maskCssComments(rawSource);
-		const references = [
-			...[...source.matchAll(/composes\s*:[^;{}]*?\bfrom\s+["']([^"']+)["']/g)].map((match) => match[1]),
-			...[...source.matchAll(/@(?:use|forward)\s+["']([^"']+)["']/g)].map((match) => match[1]),
-			...[...source.matchAll(/@import\s+(?:\([^)]*\)\s*)?(?:([^;{}]+);|([^;{}\r\n]+))/g)].flatMap((statement) => [...(statement[1] ?? statement[2]).matchAll(/["']([^"']+)["']/g)].map((match) => match[1])),
-			...[...source.matchAll(/@import\s+url\(\s*([^"'()\s]+)\s*\)/g)].map((match) => match[1])
-		];
-		for (const reference of new Set(references)) for (const target of stylesheetReferenceTargets(path, reference, styleSources)) {
-			if (target === path || !isStylesheetModule(target) && !isPreprocessorPath(target)) continue;
-			const paths = dependents.get(target) ?? [];
-			paths.push(path);
-			dependents.set(target, paths);
+	const allPossibleTargets = [...styleSources.keys()].filter((path) => isStylesheetModule(path) || isPreprocessorPath(path));
+	for (const [path, source] of styleSources) {
+		let references;
+		try {
+			const analysis = stylesheetAnalysis(path, source);
+			references = analysis.references;
+			if (analysis.unverifiable) references = [...references, ...allPossibleTargets];
+		} catch {
+			references = allPossibleTargets;
+		}
+		for (const reference of new Set(references)) {
+			const targets = styleSources.has(reference) ? [reference] : stylesheetReferenceTargets(path, reference, styleSources);
+			for (const target of targets) {
+				if (target === path || !isStylesheetModule(target) && !isPreprocessorPath(target)) continue;
+				const paths = dependents.get(target) ?? [];
+				paths.push(path);
+				dependents.set(target, paths);
+			}
 		}
 	}
 	for (const [target, paths] of dependents) dependents.set(target, [...new Set(paths)].sort());
@@ -462,63 +348,8 @@ function stylesheetReferenceTargets(importer, reference, styleSources) {
 		join(target, `index${syntax}`)
 	])).filter((path) => styleSources.has(path));
 }
-function cssImports(source) {
-	const imports = [];
-	const masked = maskCssComments(source);
-	let depth = 0;
-	let quote;
-	let importsAllowed = true;
-	for (let index = 0; index < masked.length; index += 1) {
-		const character = masked[index];
-		if (quote) {
-			if (character === "\\") index += 1;
-			else if (character === quote) quote = void 0;
-			continue;
-		}
-		if (character === "\"" || character === "'") {
-			quote = character;
-			continue;
-		}
-		if (character === "{") {
-			depth += 1;
-			importsAllowed = false;
-			continue;
-		}
-		if (character === "}") {
-			depth = Math.max(0, depth - 1);
-			continue;
-		}
-		if (!importsAllowed || depth !== 0 || masked.slice(index, index + 7).toLowerCase() !== "@import" || /[-\w]/.test(masked[index + 7] ?? "")) continue;
-		let end = index + 7;
-		let importQuote;
-		let parentheses = 0;
-		for (; end < masked.length; end += 1) {
-			const next = masked[end];
-			if (importQuote) {
-				if (next === "\\") end += 1;
-				else if (next === importQuote) importQuote = void 0;
-			} else if (next === "\"" || next === "'") importQuote = next;
-			else if (next === "(") parentheses += 1;
-			else if (next === ")") parentheses = Math.max(0, parentheses - 1);
-			else if (next === ";" && parentheses === 0) break;
-		}
-		if (end >= masked.length) continue;
-		const statement = masked.slice(index, end + 1);
-		const match = /^@import\s+(?:url\(\s*)?(?:["']([^"']+)["']|([^"'()\s;]+))\s*\)?\s*([^;]*);$/i.exec(statement);
-		if (match) imports.push({
-			href: match[1] ?? match[2],
-			media: match[3].trim(),
-			start: index,
-			end: end + 1
-		});
-		index = end;
-	}
-	const offsets = utf8OffsetMap(source, imports.flatMap((imported) => [imported.start, imported.end]));
-	return imports.map((imported) => ({
-		...imported,
-		start: offsets.get(imported.start) ?? imported.start,
-		end: offsets.get(imported.end) ?? imported.end
-	}));
+function cssImports(path, source) {
+	return stylesheetAnalysis(path, source).imports;
 }
 //#endregion
 //#region src/discovery.ts
@@ -528,7 +359,7 @@ async function resolveScope(options) {
 	const currentPackage = await findPackageRoot(cwd);
 	const gitRoot = await findGitRoot(currentPackage);
 	const workspaceRoot = gitRoot && !await isIgnoredByGit(gitRoot, currentPackage) ? gitRoot : currentPackage;
-	const allPaths = await discoverFiles(workspaceRoot, workspaceRoot === gitRoot);
+	const allPaths = workspaceRoot === gitRoot ? await discoverGitFiles(workspaceRoot) : await collectFiles(workspaceRoot, isRelevantDiscoveredFile);
 	const scannedPaths = workspaceRoot === gitRoot ? [.../* @__PURE__ */ new Set([...allPaths, ...await collectFiles(workspaceRoot, isRelevantDiscoveredFile)])] : [...allPaths];
 	const explicitStyle = options.styleFile ? resolve(cwd, options.styleFile) : void 0;
 	const configuredEntry = options.tailwindCss ? resolve(cwd, options.tailwindCss) : void 0;
@@ -589,6 +420,28 @@ async function findGitRoot(cwd) {
 		return;
 	}
 }
+async function scannerIgnoredPaths(workspaceRoot, paths) {
+	if (paths.length === 0 || await findGitRoot(workspaceRoot) !== workspaceRoot) return /* @__PURE__ */ new Set();
+	return new Promise((resolvePromise) => {
+		execFile("git", [
+			"check-ignore",
+			"--no-index",
+			"-z",
+			"--stdin"
+		], {
+			cwd: workspaceRoot,
+			maxBuffer: 67108864
+		}, (error, stdout) => {
+			if (error !== null && error.code !== 1) {
+				resolvePromise(new Set(paths));
+				return;
+			}
+			const ignored = /* @__PURE__ */ new Set();
+			for (const entry of stdout.split("\0")) if (entry) ignored.add(resolve(workspaceRoot, entry));
+			resolvePromise(ignored);
+		}).stdin?.end(paths.map((path) => `${relative(workspaceRoot, path)}\0`).join(""));
+	});
+}
 async function isIgnoredByGit(gitRoot, path) {
 	if (gitRoot === path) return false;
 	try {
@@ -603,8 +456,7 @@ async function isIgnoredByGit(gitRoot, path) {
 		return false;
 	}
 }
-async function discoverFiles(root, useGit) {
-	if (!useGit) return collectFiles(root, isRelevantDiscoveredFile);
+async function discoverGitFiles(root) {
 	const { stdout } = await run("git", [
 		"ls-files",
 		"-co",
@@ -614,7 +466,7 @@ async function discoverFiles(root, useGit) {
 		"."
 	], {
 		cwd: root,
-		maxBuffer: 64 * 1024 * 1024
+		maxBuffer: 67108864
 	});
 	const paths = stdout.split("\0").filter(Boolean).map((path) => resolve(root, path)).filter((path) => !hasIgnoredDirectory(root, path) && isRelevantDiscoveredFile(path));
 	return (await Promise.all(paths.map(async (path) => {
@@ -645,7 +497,6 @@ async function collectFiles(root, include) {
 	const files = [];
 	async function visit(directory) {
 		const entries = await readdir(directory, { withFileTypes: true });
-		entries.sort((left, right) => left.name.localeCompare(right.name));
 		for (const entry of entries) {
 			const path = join(directory, entry.name);
 			if (entry.isDirectory()) {
@@ -657,6 +508,478 @@ async function collectFiles(root, include) {
 	return files;
 }
 //#endregion
+//#region src/parser/html.ts
+const TEMPLATE_MARKERS = /\{\{|\}\}|\$\{|<%|%>|<#|#>|\[%|%\]/;
+function parseHtmlSource(path, source) {
+	const errors = [];
+	const document = parse(source, {
+		sourceCodeLocationInfo: true,
+		scriptingEnabled: false,
+		onParseError(error) {
+			if (error.code !== "missing-doctype") errors.push(error);
+		}
+	});
+	if (errors.length > 0) throw new Error(`Failed to parse ${path}: ${errors.map((error) => error.code).join(", ")}`);
+	const links = [];
+	const bases = [];
+	const elements = [];
+	const dynamicAttributes = [];
+	const scriptTexts = [];
+	let hasStyle = false;
+	const unquoted = (attribute) => source[attribute.start - 1] !== "\"" && source[attribute.start - 1] !== "'";
+	function visit(node) {
+		if (node.tagName === "style") hasStyle = true;
+		if (node.tagName === "script") {
+			for (const child of node.childNodes ?? []) if (child.nodeName === "#text" && child.value) scriptTexts.push(child.value);
+		}
+		if (node.tagName) {
+			const attributes = new Map((node.attrs ?? []).map((attribute) => [attribute.name, attribute.value]));
+			const locations = node.sourceCodeLocation?.attrs;
+			if (locations) {
+				if (node.tagName === "link" && stylesheetRel(attributes.get("rel")) && !attributes.has("disabled")) {
+					const href = locatedAttribute(source, locations.href, attributes.get("href"));
+					const media = locatedAttribute(source, locations.media, attributes.get("media"));
+					const tag = node.sourceCodeLocation?.startTag ?? node.sourceCodeLocation;
+					if (href && tag) links.push({
+						href: href.value,
+						media: media?.value ?? "",
+						start: href.start,
+						end: href.end,
+						tagStart: tag.startOffset,
+						tagEnd: tag.endOffset
+					});
+				}
+				if (node.tagName === "base" && bases.length === 0) {
+					const href = locatedAttribute(source, locations.href, attributes.get("href"));
+					if (href) bases.push({
+						href: href.value,
+						writable: href.writable,
+						start: href.start,
+						end: href.end
+					});
+				}
+				let classAttribute = locatedAttribute(source, locations.class, attributes.get("class"));
+				const idAttribute = locatedAttribute(source, locations.id, attributes.get("id"));
+				const dynamic = (!classAttribute && idAttribute && locations.class ? {
+					start: locations.class.startOffset,
+					end: locations.class.endOffset
+				} : void 0) ?? [classAttribute, idAttribute].find((attribute) => attribute && (!attribute.writable || TEMPLATE_MARKERS.test(attribute.value))) ?? (classAttribute && unquoted(classAttribute) ? classAttribute : void 0);
+				if (dynamic) dynamicAttributes.push({
+					start: dynamic.start,
+					end: dynamic.end
+				});
+				else if (classAttribute || idAttribute) {
+					if (!classAttribute && idAttribute) {
+						const startTag = node.sourceCodeLocation?.startTag;
+						if (startTag && source[startTag.endOffset - 1] === ">") {
+							const insertion = classInsertionOffset(source, startTag.startOffset, startTag.endOffset - 1);
+							classAttribute = {
+								value: "",
+								start: insertion,
+								end: insertion,
+								synthetic: true
+							};
+						}
+					}
+					elements.push({
+						classAttribute,
+						idAttribute
+					});
+				}
+			}
+		}
+		for (const child of node.childNodes ?? []) visit(child);
+		if (node.content) visit(node.content);
+	}
+	visit(document);
+	return {
+		...toByteOffsets(source, {
+			links,
+			bases,
+			elements,
+			dynamicAttributes
+		}),
+		scriptText: scriptTexts.join("\n"),
+		hasStyle
+	};
+}
+function utf8OffsetMap(source, indices) {
+	const sorted = [...new Set(indices)].sort((left, right) => left - right);
+	const map = /* @__PURE__ */ new Map();
+	let lastIndex = 0;
+	let bytes = 0;
+	for (const index of sorted) {
+		bytes += Buffer.byteLength(source.slice(lastIndex, index));
+		lastIndex = index;
+		map.set(index, bytes);
+	}
+	return map;
+}
+function offsetLookup(offsets) {
+	return (index) => {
+		const byte = offsets.get(index);
+		if (byte === void 0) throw new Error(`No byte offset was mapped for index ${index}`);
+		return byte;
+	};
+}
+function toByteOffsets(source, parsed) {
+	const offset = offsetLookup(utf8OffsetMap(source, [
+		...parsed.links.flatMap((link) => [
+			link.start,
+			link.end,
+			link.tagStart,
+			link.tagEnd
+		]),
+		...parsed.bases.flatMap((base) => [base.start, base.end]),
+		...parsed.elements.flatMap((element) => [element.classAttribute, element.idAttribute].flatMap((value) => value ? [value.start, value.end] : [])),
+		...parsed.dynamicAttributes.flatMap((value) => [value.start, value.end])
+	]));
+	const attribute = (value) => ({
+		...value,
+		start: offset(value.start),
+		end: offset(value.end)
+	});
+	return {
+		links: parsed.links.map((link) => ({
+			...link,
+			start: offset(link.start),
+			end: offset(link.end),
+			tagStart: offset(link.tagStart),
+			tagEnd: offset(link.tagEnd)
+		})),
+		bases: parsed.bases.map((base) => attribute(base)),
+		elements: parsed.elements.map((element) => ({
+			classAttribute: element.classAttribute && attribute(element.classAttribute),
+			idAttribute: element.idAttribute && attribute(element.idAttribute)
+		})),
+		dynamicAttributes: parsed.dynamicAttributes.map((value) => attribute(value))
+	};
+}
+function classInsertionOffset(source, floor, tagEnd) {
+	let offset = tagEnd;
+	if (source[offset - 1] === "/") offset -= 1;
+	while (offset > floor && /\s/.test(source[offset - 1] ?? "")) offset -= 1;
+	return offset;
+}
+function stylesheetRel(value = "") {
+	const tokens = value.toLowerCase().split(/\s+/);
+	return tokens.includes("stylesheet") && !tokens.includes("alternate");
+}
+function locatedAttribute(source, location, parsedValue) {
+	if (!location || parsedValue === void 0) return void 0;
+	const raw = source.slice(location.startOffset, location.endOffset);
+	const equals = raw.indexOf("=");
+	if (equals < 0) return void 0;
+	let start = equals + 1;
+	while (/\s/.test(raw[start] ?? "")) start += 1;
+	const quote = raw[start];
+	let end;
+	if (quote === "\"" || quote === "'") {
+		start += 1;
+		end = raw.lastIndexOf(quote);
+		if (end < start) return void 0;
+	} else {
+		end = start;
+		while (end < raw.length && !/\s/.test(raw[end] ?? "")) end += 1;
+	}
+	const value = raw.slice(start, end);
+	return {
+		value: value.includes("&") ? parsedValue : value,
+		writable: !value.includes("&"),
+		start: location.startOffset + start,
+		end: location.startOffset + end
+	};
+}
+//#endregion
+//#region src/plan/entry.ts
+function emitsUtilities(specifier) {
+	return specifier === "tailwindcss" || specifier === "tailwindcss/utilities" || specifier === "tailwindcss/utilities.css";
+}
+function hasTailwindImport(source) {
+	return cssDirectives(source)?.some((directive) => directive.kind === "import" && directive.specifier !== null && emitsUtilities(directive.specifier)) ?? false;
+}
+function tailwindEntryCatalog(styleSources, pathOwners) {
+	const catalog = /* @__PURE__ */ new Map();
+	for (const [path, source] of styleSources) {
+		if (extname(path) !== ".css") continue;
+		if (!hasTailwindImport(source)) continue;
+		const owner = pathOwners.get(path);
+		if (owner === void 0) continue;
+		const entries = catalog.get(owner) ?? [];
+		entries.push(path);
+		catalog.set(owner, entries);
+	}
+	for (const entries of catalog.values()) entries.sort();
+	return catalog;
+}
+function cssDirectives(source) {
+	return cssDirectives$1(source)?.filter((directive) => directive !== null && typeof directive === "object" && "kind" in directive && typeof directive.kind === "string") ?? null;
+}
+function entryGraphSheets(entry, styleSources) {
+	const sheets = [];
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [entry];
+	while (pending.length > 0) {
+		const path = pending.pop();
+		if (path === void 0 || seen.has(path)) continue;
+		seen.add(path);
+		const raw = styleSources.get(path);
+		if (raw === void 0) return null;
+		const directives = cssDirectives(raw);
+		if (directives === null) return null;
+		sheets.push({
+			path,
+			directives
+		});
+		for (const directive of directives) {
+			if (directive.kind !== "import") continue;
+			if (directive.specifier === null) return null;
+			const spec = directive.specifier;
+			if (directive.tailwind) continue;
+			if (!spec.startsWith(".") && !spec.startsWith("/")) {
+				let resolved;
+				try {
+					resolved = createRequire(join(dirname(path), "package.json")).resolve(spec);
+				} catch {
+					return null;
+				}
+				if (/[\\/]node_modules[\\/]/.test(resolved)) continue;
+				pending.push(resolved);
+				continue;
+			}
+			const resolved = resolve(dirname(path), spec);
+			pending.push(styleSources.has(resolved) ? resolved : `${resolved}.css`);
+		}
+	}
+	return sheets;
+}
+function scanProof(options) {
+	const sheets = entryGraphSheets(options.entry, new Map([...options.styleSources ?? [], [options.entry, options.entrySource]]));
+	if (sheets === null) return null;
+	let literal = false;
+	let automaticDisabled = false;
+	for (const { path, directives } of sheets) {
+		const base = dirname(path);
+		const coversChild = (scope) => {
+			if (scope.includes("*")) return false;
+			return isWithin(resolve(base, scope), options.packageRoot);
+		};
+		const excludesChild = (scope) => {
+			const stripped = resolve(base, scope.replace(/\*.*$/, ""));
+			if (scope.includes("*")) return options.packageRoot.startsWith(stripped) || stripped.startsWith(options.packageRoot);
+			return isWithin(stripped, options.packageRoot) || isWithin(options.packageRoot, stripped);
+		};
+		for (const directive of directives) if (directive.kind === "source") {
+			if (directive.inline) continue;
+			if (directive.unreadable || directive.scope === null) return null;
+			if (directive.not) {
+				if (excludesChild(directive.scope)) return null;
+			} else if (coversChild(directive.scope)) literal = true;
+		} else if (directive.kind === "import" && directive.tailwind) {
+			if (directive.sourceUnreadable) return null;
+			if (directive.source === "none") automaticDisabled = true;
+			else if (directive.source !== null) if (coversChild(directive.source)) literal = true;
+			else automaticDisabled = true;
+		}
+	}
+	if (literal) return "literal";
+	if (automaticDisabled) return null;
+	return isWithin(dirname(options.entry), options.packageRoot) ? "automatic" : null;
+}
+const OPAQUE_SOURCE_IMPORT = {
+	specifier: "#unverifiable-source",
+	typeOnly: false,
+	dynamic: true
+};
+function sourceImports(file) {
+	const extension = extname(file.path);
+	if (extension === ".html") return [];
+	if (extension === ".vue") return file.sourceImports && !file.sourceImportsUnverifiable ? file.sourceImports : [OPAQUE_SOURCE_IMPORT];
+	try {
+		return sourceAnalysis(file.path, file.source).imports;
+	} catch {
+		return [OPAQUE_SOURCE_IMPORT];
+	}
+}
+const RESOLVABLE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".vue"
+];
+function resolveImport(fromDir, spec, known) {
+	if (!spec.startsWith(".")) return void 0;
+	const base = resolve(fromDir, spec);
+	const emitted = base.match(/^(.*)\.(?:mjs|cjs|js|jsx)$/);
+	return [
+		base,
+		...emitted ? [
+			".ts",
+			".tsx",
+			".mts",
+			".cts"
+		].map((extension) => `${emitted[1]}${extension}`) : [],
+		...RESOLVABLE_EXTENSIONS.map((extension) => `${base}${extension}`),
+		...RESOLVABLE_EXTENSIONS.map((extension) => join(base, `index${extension}`))
+	].find((candidate) => known.has(candidate));
+}
+function scriptLikeSpecifier(spec) {
+	if (!spec.startsWith(".")) return false;
+	const trimmed = spec.split(/[?#]/, 1)[0];
+	return /\.(?:m?[jt]sx?|c[jt]s|vue)$/.test(trimmed) || !/\.[^/.]+$/.test(trimmed);
+}
+function externalPackageSpecifier(spec) {
+	return /^(?:node:[\w/.-]+|(?:@[a-z0-9~][\w.~-]*\/)?[a-z0-9~][\w.~-]*(?:\/.*)?)$/.test(spec);
+}
+function importEdges(files) {
+	const known = new Set(files.map((file) => file.path));
+	const edges = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		if (extname(file.path) === ".html") continue;
+		const targets = [];
+		for (const record of sourceImports(file)) {
+			if (record.typeOnly) continue;
+			const resolved = resolveImport(dirname(file.path), record.specifier, known);
+			if (resolved !== void 0) targets.push(resolved);
+		}
+		edges.set(file.path, targets);
+	}
+	return edges;
+}
+function reachableFrom(starts, edges) {
+	const reached = new Set(starts);
+	const pending = [...reached];
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (current === void 0) break;
+		for (const target of edges.get(current) ?? []) if (!reached.has(target)) {
+			reached.add(target);
+			pending.push(target);
+		}
+	}
+	return reached;
+}
+function exposedFiles(packageRoot, packageJson, files, inboundSeeds) {
+	const known = new Set(files.map((file) => file.path));
+	const specs = [];
+	const collect = (value) => {
+		if (typeof value === "string") {
+			if (value.includes("*")) return "all";
+			specs.push(value);
+			return;
+		}
+		if (value !== null && typeof value === "object") for (const [key, child] of Object.entries(value)) {
+			if (key.includes("*")) return "all";
+			if (collect(child) === "all") return "all";
+		}
+	};
+	for (const field of [
+		"main",
+		"module",
+		"exports",
+		"browser"
+	]) if (collect(packageJson[field]) === "all") return "all";
+	if (packageJson.exports === void 0 && packageJson.private !== true) return "all";
+	const declared = specs.length > 0;
+	const entryFileSeeds = [...inboundSeeds];
+	if (!declared) specs.push("./index");
+	const entryFiles = [...entryFileSeeds];
+	for (const spec of specs) {
+		const resolved = resolveImport(packageRoot, spec.startsWith(".") ? spec : `./${spec}`, known);
+		if (resolved === void 0) {
+			if (declared) return "all";
+			continue;
+		}
+		entryFiles.push(resolved);
+	}
+	const byPath = new Map(files.map((file) => [file.path, file]));
+	const exposed = new Set(entryFiles);
+	const pending = [...entryFiles];
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (current === void 0) break;
+		const file = byPath.get(current);
+		if (file === void 0 || extname(file.path) === ".html") continue;
+		for (const record of sourceImports(file)) {
+			if (record.typeOnly) continue;
+			const resolved = resolveImport(dirname(file.path), record.specifier, known);
+			if (resolved === void 0) {
+				if (scriptLikeSpecifier(record.specifier) || !record.specifier.startsWith(".") && !externalPackageSpecifier(record.specifier)) return "all";
+				continue;
+			}
+			if (!exposed.has(resolved)) {
+				exposed.add(resolved);
+				pending.push(resolved);
+			}
+		}
+	}
+	return exposed;
+}
+function proveSharedEntry(options) {
+	const scan = scanProof(options);
+	if (scan === null) return null;
+	const ownedSources = options.packageSources.filter((file) => options.owned(file.path));
+	const loaders = ownedSources.filter((file) => options.writable(file.path)).filter((file) => (file.htmlStylesheets ?? []).some((context) => context.cssPath === options.entry) || htmlLinksEntry(file, options.entry) || extname(file.path) !== ".html" && importsEntry(file, options.entry)).map((file) => file.path);
+	if (loaders.length === 0) return null;
+	const reachable = reachableFrom(loaders, importEdges(ownedSources));
+	const ownedPaths = new Set(ownedSources.map((file) => file.path));
+	const packageName = typeof options.packageJson.name === "string" ? options.packageJson.name : void 0;
+	const resolveInbound = (fromDir, spec) => {
+		const relative = resolveImport(fromDir, spec, ownedPaths);
+		if (relative !== void 0) return relative;
+		if (packageName !== void 0 && spec.startsWith(`${packageName}/`)) return resolveImport(options.packageRoot, `./${spec.slice(packageName.length + 1)}`, ownedPaths);
+	};
+	const inboundSeeds = [];
+	let foreignUnverifiable = false;
+	for (const file of options.packageSources) {
+		if (options.owned(file.path) || extname(file.path) === ".html") continue;
+		if (importsEntry(file, options.entry)) continue;
+		const records = sourceImports(file);
+		if (records.includes(OPAQUE_SOURCE_IMPORT)) {
+			foreignUnverifiable = true;
+			continue;
+		}
+		for (const record of records) {
+			if (record.typeOnly) continue;
+			const resolved = resolveInbound(dirname(file.path), record.specifier);
+			if (resolved !== void 0) inboundSeeds.push(resolved);
+		}
+	}
+	const exposed = foreignUnverifiable ? "all" : exposedFiles(options.packageRoot, options.packageJson, ownedSources, inboundSeeds);
+	const provenConsumer = (consumer) => options.owned(consumer.path) && !sourceImports(consumer).includes(OPAQUE_SOURCE_IMPORT) && reachable.has(consumer.path) && (exposed === "all" ? false : !exposed.has(consumer.path)) && (scan === "literal" || !options.ignoredPaths.has(consumer.path));
+	return {
+		provenConsumer,
+		provenStyle: (consumers) => consumers.length > 0 && consumers.every(provenConsumer)
+	};
+}
+function htmlLinksEntry(file, entry) {
+	if (extname(file.path) !== ".html") return false;
+	try {
+		const parsed = parseHtmlSource(file.path, file.source);
+		if (parsed.bases.length > 0) return false;
+		return parsed.links.some((link) => {
+			const media = link.media.trim().toLowerCase();
+			if (media !== "" && media !== "all") return false;
+			const href = link.href.split(/[?#]/, 1)[0];
+			if (!href || /^[a-z][a-z0-9+.-]*:|^\/\//i.test(href)) return false;
+			return resolve(dirname(file.path), href) === entry;
+		});
+	} catch {
+		return false;
+	}
+}
+function importsStylesheet(file, stylePath) {
+	return sourceImports(file).some((record) => record === OPAQUE_SOURCE_IMPORT && file.source.includes(basename(stylePath)) || !record.typeOnly && record.specifier.startsWith(".") && resolve(dirname(file.path), record.specifier) === stylePath);
+}
+function importsEntry(file, entry) {
+	return sourceImports(file).some((record) => !record.typeOnly && !record.dynamic && record.specifier.startsWith(".") && resolve(dirname(file.path), record.specifier) === entry);
+}
+//#endregion
 //#region src/plan/html.ts
 async function preparePackageHtml({ packageRoot, sourceFiles, styleSources, snapshots, pathOwners, styleDependents }) {
 	const files = [];
@@ -781,7 +1104,7 @@ async function collectHtmlStyleContexts(state) {
 		analyzable: true
 	});
 	if (extname(state.path) !== ".css") return;
-	for (const imported of cssImports(source)) {
+	for (const imported of cssImports(state.path, source)) {
 		const variants = mediaVariants(imported.media);
 		if (variants === void 0) {
 			state.warnings.push(htmlWarning("unsupported-link-media", state.path, imported.start, imported.end, `The stylesheet import media condition ${JSON.stringify(imported.media)} cannot be represented safely.`));
@@ -804,7 +1127,7 @@ function inferredPreprocessorPath(state) {
 	return matches.length === 1 ? matches[0] : void 0;
 }
 function addInferredPreprocessorContext(state) {
-	if (state.styleSources.has(state.path) && state.sourceFiles.some((file) => extname(file.path) !== ".html" && sourceReferencesStyle(file, state.path))) return false;
+	if (state.styleSources.has(state.path) && state.sourceFiles.some((file) => extname(file.path) !== ".html" && importsStylesheet(file, state.path))) return false;
 	const path = inferredPreprocessorPath(state);
 	if (!path) return false;
 	state.generatedPaths.add(state.path);
@@ -855,22 +1178,14 @@ function htmlWarning(code, file, start, end, message) {
 }
 //#endregion
 //#region src/tailwind.ts
-function resolveTailwindEntry(stylePaths, styleSources, configuredPath) {
-	const entries = stylePaths.filter((path) => {
-		if (extname(path) !== ".css") return false;
-		const source = maskCssComments(styleSources.get(path) ?? "");
-		return /@import\s+["']tailwindcss(?:\/[^"']*)?["']/.test(source);
-	});
-	if (configuredPath) return {
-		path: configuredPath,
-		entries
-	};
+function findTailwindEntries(stylePaths, styleSources) {
+	return stylePaths.filter((path) => extname(path) === ".css" && importSpecifiers(styleSources.get(path) ?? "").some((specifier) => specifier === "tailwindcss" || specifier.startsWith("tailwindcss/")));
+}
+function selectTailwindEntry(entries, configuredPath) {
+	if (configuredPath) return configuredPath;
 	if (entries.length === 0) throw new Error("No Tailwind v4 CSS entry was found. Pass --tailwind-css.");
 	if (entries.length > 1) throw new Error("Multiple Tailwind CSS entries were found. Pass --tailwind-css.");
-	return {
-		path: entries[0],
-		entries
-	};
+	return entries[0];
 }
 async function loadTailwind(packageRoot, tailwindCss, snapshots, workspaceRoot) {
 	const projectRequire = createRequire(join(packageRoot, "package.json"));
@@ -884,47 +1199,10 @@ async function loadTailwind(packageRoot, tailwindCss, snapshots, workspaceRoot)
 	if (!String(packageJson.version).startsWith("4.")) throw new Error(`Tailwind v4 is required; found ${packageJson.version}.`);
 	const { __unstable__loadDesignSystem: loadDesignSystem } = await loadProjectModule(packageRoot, "tailwindcss", "Tailwind v4 must be installed in the target project.");
 	const css = await snapshotFile(snapshots, tailwindCss);
-	const base = dirname(tailwindCss);
-	const loadModule = createModuleLoader(snapshots, workspaceRoot);
-	const loadStylesheet = createStylesheetLoader(projectRequire, packagePath, snapshots, workspaceRoot);
-	const themeTokens = {
-		...extractThemeTokens(await readFile(join(dirname(packagePath), "theme.css"), "utf8")),
-		...await extractThemeTokensFromGraph(css, base, loadStylesheet)
-	};
-	return {
-		designSystem: await loadDesignSystem(css, {
-			base,
-			loadModule,
-			loadStylesheet
-		}),
-		css,
-		path: tailwindCss,
-		themeTokens
-	};
-}
-function extractThemeTokens(css) {
-	const tokens = {};
-	for (const block of css.matchAll(/@theme[^{]*\{([^}]*)\}/gs)) for (const match of block[1].matchAll(/--([\w-]+):\s*([^;{}]+);/g)) tokens[match[1]] = match[2].trim();
-	return tokens;
-}
-async function extractThemeTokensFromGraph(css, base, loadStylesheet, seen = /* @__PURE__ */ new Set()) {
-	const tokens = {};
-	for (const match of css.matchAll(/@import\s+["']([^"']+)["']/g)) {
-		const key = `${base}\0${match[1]}`;
-		if (seen.has(key)) continue;
-		seen.add(key);
-		const loaded = await loadStylesheet(match[1], base);
-		Object.assign(tokens, await extractThemeTokensFromGraph(loaded.content, loaded.base, loadStylesheet, seen));
-	}
-	return Object.assign(tokens, extractThemeTokens(css));
-}
-function invalidCandidates(tailwind, candidates) {
-	const generated = tailwind.designSystem.candidatesToCss(candidates);
-	return candidates.filter((_, index) => generated[index] === null);
-}
-function createModuleLoader(snapshots, workspaceRoot) {
-	return async (id, base) => {
-		const path = createRequire(join(base, "package.json")).resolve(id);
+	const base = dirname(tailwindCss);
+	const tailwindRoot = dirname(packagePath);
+	const loadModule = async (id, moduleBase) => {
+		const path = createRequire(join(moduleBase, "package.json")).resolve(id);
 		if (isProjectInput(workspaceRoot, path)) await snapshotFile(snapshots, path);
 		const imported = await import(pathToFileURL(path).href);
 		return {
@@ -933,27 +1211,278 @@ function createModuleLoader(snapshots, workspaceRoot) {
 			module: imported.default ?? imported
 		};
 	};
-}
-function createStylesheetLoader(projectRequire, tailwindPackagePath, snapshots, workspaceRoot) {
-	const tailwindRoot = dirname(tailwindPackagePath);
-	return async (id, base) => {
+	const loadStylesheet = async (id, sheetBase) => {
 		let path;
 		if (id === "tailwindcss") path = join(tailwindRoot, "index.css");
 		else if (id.startsWith("tailwindcss/")) {
 			const subpath = id.slice(12);
 			path = join(tailwindRoot, subpath.endsWith(".css") ? subpath : `${subpath}.css`);
-		} else if (id.startsWith(".") || isAbsolute(id)) path = resolve(base, id);
+		} else if (id.startsWith(".") || isAbsolute(id)) path = resolve(sheetBase, id);
 		else path = projectRequire.resolve(id);
 		return {
 			content: isProjectInput(workspaceRoot, path) ? await snapshotFile(snapshots, path) : await readFile(path, "utf8"),
 			base: dirname(path)
 		};
 	};
+	const defaultTheme = await readFile(join(dirname(packagePath), "theme.css"), "utf8");
+	const graphSources = [];
+	const themeTokens = {
+		...extractThemeTokens("tailwind-default.theme.css", defaultTheme),
+		...await extractThemeTokensFromGraph(tailwindCss, css, base, loadStylesheet, graphSources)
+	};
+	graphSources.push({
+		path: tailwindCss,
+		source: css
+	});
+	const designSystem = await loadDesignSystem(css, {
+		base,
+		loadModule,
+		loadStylesheet
+	});
+	const loadWith = (replacement) => loadDesignSystem(replacement, {
+		base,
+		loadModule,
+		loadStylesheet
+	});
+	return {
+		designSystem,
+		css,
+		path: tailwindCss,
+		themeTokens,
+		graphSources,
+		loadWith
+	};
+}
+function extractThemeTokens(key, css) {
+	return stylesheetAnalysis(key, css).themeTokens;
+}
+function importSpecifiers(css) {
+	return (cssDirectives$1(css) ?? []).flatMap((directive) => directive !== null && typeof directive === "object" && "kind" in directive && directive.kind === "import" && "specifier" in directive && typeof directive.specifier === "string" ? [directive.specifier] : []);
+}
+async function extractThemeTokensFromGraph(identity, css, base, loadStylesheet, graphSources, seen = /* @__PURE__ */ new Set()) {
+	const tokens = {};
+	for (const spec of importSpecifiers(css)) {
+		const key = `${base}\0${spec}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		const loaded = await loadStylesheet(spec, base);
+		if (spec !== "tailwindcss" && !spec.startsWith("tailwindcss/")) graphSources.push({
+			path: key,
+			source: loaded.content
+		});
+		Object.assign(tokens, await extractThemeTokensFromGraph(key, loaded.content, loaded.base, loadStylesheet, graphSources, seen));
+	}
+	return Object.assign(tokens, extractThemeTokens(`${identity}.theme.css`, css));
+}
+function invalidCandidates(system, candidates) {
+	const generated = system.candidatesToCss(candidates);
+	return candidates.filter((_, index) => generated[index] === null);
+}
+//#endregion
+//#region src/plan/media.ts
+const GENERATED_NAMESPACE = "twm-media";
+/**
+* Resolve one fixed name per key across a complete entry group.
+*
+* Resolution follows the RFC order: a built-in candidate with a verified
+* effective expansion, an existing breakpoint matched by exact value and
+* verified the same way, an adopted definition whose name, normalized
+* meaning, and effective expansion equal what the migration would emit,
+* the readable generated name, the digest name, and finally the
+* arbitrary-variant fallback. Reservation is ownership-blind:
+* authored names with any different meaning, active theme names, explicit
+* reserved names such as inert scanned candidates, and any name the design
+* system resolves all block a generated name.
+*/
+function resolveMediaNames(collections, themeTokens, probes, reservedNames = []) {
+	const components = mergeComponents(collections);
+	const authoredKeysByName = mergeAuthoredVariants(collections);
+	const reserved = new Set(reservedNames);
+	for (const token of Object.keys(themeTokens)) if (token.startsWith("breakpoint-")) reserved.add(token.slice(11));
+	const claimed = /* @__PURE__ */ new Set();
+	const adoptableKey = (name) => {
+		const keys = authoredKeysByName.get(name);
+		if (keys === void 0 || keys.size !== 1) return null;
+		const [key] = keys;
+		return key ?? null;
+	};
+	const taken = (name) => claimed.has(name) || reserved.has(name) || authoredKeysByName.has(name) || probes.resolves(name);
+	const names = /* @__PURE__ */ new Map();
+	const fallbacks = /* @__PURE__ */ new Set();
+	for (const component of components) {
+		const resolved = (name, kind) => {
+			claimed.add(name);
+			names.set(component.key, {
+				name,
+				kind
+			});
+		};
+		if (component.builtin !== null && probes.expansionMatches(component.builtin, component.key)) {
+			resolved(component.builtin, "builtin");
+			continue;
+		}
+		if (component.breakpoint !== null && probes.expansionMatches(component.breakpoint, component.key)) {
+			resolved(component.breakpoint, "breakpoint");
+			continue;
+		}
+		const digestName = `${GENERATED_NAMESPACE}-${component.digest}`;
+		const candidates = component.readableName === null ? [digestName] : [component.readableName, digestName];
+		let done = false;
+		for (const candidate of candidates) {
+			if (adoptableKey(candidate) === component.key && !claimed.has(candidate) && probes.expansionMatches(candidate, component.key)) {
+				resolved(candidate, "adopted");
+				done = true;
+				break;
+			}
+			if (!taken(candidate)) {
+				resolved(candidate, "generated");
+				done = true;
+				break;
+			}
+		}
+		if (!done) fallbacks.add(component.key);
+	}
+	return {
+		names,
+		fallbacks
+	};
+}
+function mergeComponents(collections) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const collection of collections) for (const component of collection.components) if (!byKey.has(component.key)) byKey.set(component.key, component);
+	return [...byKey.values()].sort((left, right) => left.key < right.key ? -1 : left.key > right.key ? 1 : 0);
+}
+function mergeAuthoredVariants(collections) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const collection of collections) for (const variant of collection.authoredVariants) {
+		const keys = byName.get(variant.name) ?? /* @__PURE__ */ new Set();
+		keys.add(variant.mediaQueryKey);
+		byName.set(variant.name, keys);
+	}
+	return byName;
+}
+const PROBE_UTILITY = "[--tw-probe:1]";
+function probeCandidate(prefix, name) {
+	return `${prefix === null || prefix === "" ? "" : `${prefix}:`}${name}:${PROBE_UTILITY}`;
+}
+/**
+* Build the effective-expansion probes against the unaugmented loaded
+* design system. `resolves` proves only existence; `expansionMatches`
+* proves that compiling the name yields exactly one `@media` wrapper whose
+* normalized query equals the key.
+*/
+function buildMediaProbes(tailwind) {
+	const compiled = /* @__PURE__ */ new Map();
+	const prefix = tailwind.designSystem.theme.prefix;
+	const compile = (name) => {
+		let css = compiled.get(name);
+		if (css === void 0) {
+			[css = null] = tailwind.designSystem.candidatesToCss([probeCandidate(prefix, name)]);
+			compiled.set(name, css);
+		}
+		return css;
+	};
+	return {
+		resolves: (name) => compile(name) !== null,
+		expansionMatches: (name, key) => {
+			const css = compile(name);
+			if (css === null) return false;
+			return JSON.parse(mediaProbeKey(css)) === key;
+		}
+	};
+}
+/**
+* Conservative scanned-corpus reservation: every colon-chained token in the
+* package's scanned sources reserves its variant segments, so an inert
+* candidate such as `width-lte-768px:hidden` is never activated with a new
+* meaning. Over-reservation only pushes a generated name to its digest
+* form, and content-identity adoption bypasses these reservations, so
+* reruns stay idempotent.
+*/
+function scannedVariantReservations(sources) {
+	const reserved = /* @__PURE__ */ new Set();
+	for (const source of sources) for (const match of source.matchAll(/[A-Za-z][\w-]*(?::[^\s"'`{}]+)+/g)) for (const segment of match[0].split(":").slice(0, -1)) reserved.add(segment);
+	return reserved;
+}
+/**
+* Run native condition collection for one member package of an entry
+* group. Kept separate from resolution so a recoverable collection
+* failure is attributable to its member.
+*/
+function collectMemberMediaConditions(stylesheets, tailwind) {
+	return JSON.parse(collectMediaConditions(JSON.stringify({
+		stylesheets,
+		themeTokens: tailwind.themeTokens,
+		tailwindSources: tailwind.graphSources
+	})));
+}
+/**
+* Resolve the fixed map the planner consumes plus the definitions
+* extraction may emit from the group's member collections. Name
+* allocation runs once for the complete group, so different keys from
+* different packages can never independently claim one name.
+*/
+function planMediaExtraction(options) {
+	const resolution = resolveMediaNames(options.collections, options.tailwind.themeTokens, buildMediaProbes(options.tailwind), scannedVariantReservations([...options.scannedSources, ...options.tailwind.graphSources.map((graphSource) => graphSource.source)]));
+	const names = {};
+	const generated = [];
+	for (const [key, resolved] of resolution.names) {
+		names[key] = resolved.name;
+		if (resolved.kind === "generated") generated.push({
+			key,
+			name: resolved.name
+		});
+	}
+	return {
+		names,
+		generated
+	};
+}
+/**
+* The generated definitions the final plan actually uses, ordered by the
+* first applied rule that uses each name. A rule counts as applied only
+* when every one of its candidates survived into `plan.candidates`: a
+* retained global rule still applies its utilities to proven consumers,
+* while a blocked rule always contains a dropped candidate, so its
+* occurrences must not fix registration order for a candidate another rule
+* still applies. Registration order controls conflicting utility
+* precedence, so the order follows the applied rules rather than every
+* encountered condition.
+*/
+function usedGeneratedDefinitions(extraction, plan) {
+	const applied = new Set(plan.candidates);
+	const byName = new Map(extraction.generated.map((definition) => [definition.name, definition]));
+	const ordered = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const rule of plan.rules) {
+		if (!rule.candidates.every((candidate) => applied.has(candidate))) continue;
+		for (const candidate of rule.candidates) for (const segment of candidate.split(":").slice(0, -1)) {
+			const definition = byName.get(segment);
+			if (definition !== void 0 && !seen.has(segment)) {
+				seen.add(segment);
+				ordered.push(definition);
+			}
+		}
+	}
+	return ordered;
+}
+/**
+* Append the used definitions to the entry source, each as its own block,
+* matching the planner's moved-block formatting. Definitions already
+* present are recognized through adoption before this runs, so appending
+* never duplicates one.
+*/
+function appendMediaDefinitions(source, definitions) {
+	let output = source;
+	for (const { key, name } of definitions) {
+		if (!output.endsWith("\n")) output += "\n";
+		if (!output.endsWith("\n\n")) output += "\n";
+		output += `@custom-variant ${name} {\n  @media ${key} {\n    @slot;\n  }\n}\n`;
+	}
+	return output;
 }
 //#endregion
 //#region src/parser/vue.ts
-const ESCAPE_SELECTOR = /(?:::v-|:)(?:deep|global|slotted)\(([^)]*)\)/g;
-const ESCAPE_RESIDUE = /(?:>>>|\/deep\/|::v-deep|:deep|::v-slotted|:slotted|::v-global|:global)/;
 const SUPPORTED_STYLE_ATTRIBUTES = /* @__PURE__ */ new Set([
 	"lang",
 	"module",
@@ -967,6 +1496,13 @@ const SUPPORTED_STYLE_LANGUAGES = /* @__PURE__ */ new Set([
 	"sass",
 	"less"
 ]);
+const SUPPORTED_SCRIPT_LANGUAGES = /* @__PURE__ */ new Set([
+	void 0,
+	"js",
+	"jsx",
+	"ts",
+	"tsx"
+]);
 const NODE_ELEMENT = 1;
 const NODE_TEXT = 2;
 const NODE_INTERPOLATION = 5;
@@ -997,29 +1533,48 @@ function analyzeVueSource(compiler, path, source) {
 		message
 	});
 	const { descriptor, errors } = compiler.parse(source, { filename: path });
+	const styleRanges = descriptor.styles.map((style) => ({
+		start: style.loc.start.offset,
+		end: style.loc.end.offset
+	}));
+	const byteRanges = (offset) => ({
+		warnings: warnings.map((warning) => ({
+			...warning,
+			start: offset(warning.start),
+			end: offset(warning.end)
+		})),
+		styleRanges: styleRanges.map((range) => ({
+			start: offset(range.start),
+			end: offset(range.end)
+		}))
+	});
+	const retained = () => {
+		const offsets = utf8OffsetMap(source, [...warnings, ...styleRanges].flatMap((range) => [range.start, range.end]));
+		return {
+			retained: true,
+			...byteRanges(offsetLookup(offsets))
+		};
+	};
 	if (errors.length > 0) {
 		const offset = errors[0]?.loc?.start?.offset ?? 0;
 		warn("unsupported-sfc-block", offset, offset, `The SFC could not be parsed: ${errors[0].message}`);
-		return {
-			warnings: toByteWarnings(source, warnings),
-			retained: true
-		};
+		if (errors[0]?.loc?.start?.offset === 0) Object.assign(warnings[0], {
+			line: 1,
+			column: 1,
+			endLine: 1,
+			endColumn: 1
+		});
+		return retained();
 	}
 	const template = descriptor.template;
 	if (!template || template.lang || template.src) {
 		warn("unsupported-sfc-block", 0, 0, !template ? "The SFC has no template block, so its class usage cannot be analyzed." : "Only the default template language with inline content is analyzed.");
-		return {
-			warnings: toByteWarnings(source, warnings),
-			retained: true
-		};
+		return retained();
 	}
 	if (descriptor.customBlocks.length > 0) {
 		const block = descriptor.customBlocks[0];
 		warn("unsupported-sfc-block", block.loc.start.offset, block.loc.end.offset, `The custom <${block.type}> block is not analyzed.`);
-		return {
-			warnings: toByteWarnings(source, warnings),
-			retained: true
-		};
+		return retained();
 	}
 	const blocks = [];
 	const unscopedBlocks = [];
@@ -1031,6 +1586,7 @@ function analyzeVueSource(compiler, path, source) {
 	const shadowPreprocessorTexts = [];
 	const unscopedShadowPreprocessorTexts = [];
 	let escapeUnverifiable = false;
+	let opaqueStyleBlocks = false;
 	let moduleSiblingUnsupported = false;
 	for (const style of descriptor.styles) {
 		const start = style.loc.start.offset;
@@ -1041,6 +1597,7 @@ function analyzeVueSource(compiler, path, source) {
 			warn("unsupported-sfc-block", start, end, `Unsupported <style> attributes: ${unsupportedAttributes.join(", ")}.`);
 			if (usesDefaultModuleBinding) moduleSiblingUnsupported = true;
 			escapeUnverifiable = true;
+			opaqueStyleBlocks = true;
 			continue;
 		}
 		if (style.src !== void 0) {
@@ -1048,6 +1605,7 @@ function analyzeVueSource(compiler, path, source) {
 				warn("unsupported-sfc-block", start, end, "A <style module src> block is not supported.");
 				if (usesDefaultModuleBinding) moduleSiblingUnsupported = true;
 				escapeUnverifiable = true;
+				opaqueStyleBlocks = true;
 			} else styleBlockImports.push({
 				reference: style.src,
 				start,
@@ -1059,12 +1617,19 @@ function analyzeVueSource(compiler, path, source) {
 			if (usesDefaultModuleBinding) moduleSiblingUnsupported = true;
 			warn("unsupported-sfc-block", start, end, "Named <style module> blocks are not supported.");
 			shadowModuleCssTexts.push(style.content);
+			opaqueStyleBlocks = true;
 			continue;
 		}
 		if (!SUPPORTED_STYLE_LANGUAGES.has(style.lang)) {
 			if (usesDefaultModuleBinding) moduleSiblingUnsupported = true;
 			warn("preprocessor-style-block", start, end, `The <style lang="${style.lang}"> language is not supported.`);
 			shadowPreprocessorTexts.push(style.content);
+			opaqueStyleBlocks = true;
+			try {
+				if (stylesheetAnalysis(`${path}.css`, style.content).selectorsUnverifiable) escapeUnverifiable = true;
+			} catch {
+				escapeUnverifiable = true;
+			}
 			continue;
 		}
 		const outerStart = source.lastIndexOf("<style", start);
@@ -1072,6 +1637,7 @@ function analyzeVueSource(compiler, path, source) {
 		if (outerStart < 0 || !closing) {
 			warn("unsupported-sfc-block", start, end, "The style block tags could not be located.");
 			escapeUnverifiable = true;
+			opaqueStyleBlocks = true;
 			continue;
 		}
 		const block = {
@@ -1088,24 +1654,37 @@ function analyzeVueSource(compiler, path, source) {
 		}
 		if (!style.scoped) {
 			unscopedBlocks.push(block);
-			if (style.lang && style.lang !== "css") unscopedShadowPreprocessorTexts.push(style.content);
-			else unscopedShadowCssTexts.push(style.content);
+			if (style.lang && style.lang !== "css") {
+				unscopedShadowPreprocessorTexts.push(style.content);
+				try {
+					if (stylesheetAnalysis(`${path}.${style.lang}`, style.content).selectorsUnverifiable) escapeUnverifiable = true;
+				} catch {
+					escapeUnverifiable = true;
+				}
+			} else unscopedShadowCssTexts.push(style.content);
 			continue;
 		}
-		for (const [, inner] of style.content.matchAll(ESCAPE_SELECTOR)) {
-			shadowCssTexts.push(`${inner} {}`);
-			if (inner.includes("(")) escapeUnverifiable = true;
+		try {
+			const escapes = stylesheetAnalysis(`${path}.${style.lang ?? "css"}`, style.content);
+			shadowCssTexts.push(...escapes.scopeEscapes);
+			if (escapes.scopeEscapes.length > 0) block.shadowSource = escapes.scopeShadowCss.join("\n") || "/* scope escapes extracted */";
+			if (escapes.scopeEscapesUnverifiable || escapes.selectorsUnverifiable) escapeUnverifiable = true;
+		} catch {
+			escapeUnverifiable = true;
 		}
-		if (ESCAPE_RESIDUE.test(style.content.replace(ESCAPE_SELECTOR, " "))) escapeUnverifiable = true;
 		blocks.push(block);
 	}
+	const scriptLang = descriptor.scriptSetup?.lang ?? descriptor.script?.lang;
 	const state = {
 		elements: [],
 		components: [],
 		dynamic: false,
 		vHtml: false,
 		hasSlot: false,
-		expressionTexts: []
+		moduleClosureBroken: false,
+		referencesUseCssModule: false,
+		expressionReferences: /* @__PURE__ */ new Set(),
+		expressionPath: scriptLang === "ts" || scriptLang === "tsx" ? "Component.ts" : "Component.js"
 	};
 	visitTemplateNode(source, template.ast, state);
 	const alwaysRenderedRoots = template.ast.children.filter((node) => node.type === NODE_ELEMENT && (node.tagType === TAG_ELEMENT || node.tagType === TAG_COMPONENT) && !node.props?.some((prop) => prop.type === PROP_DIRECTIVE && [
@@ -1115,41 +1694,40 @@ function analyzeVueSource(compiler, path, source) {
 		"for"
 	].includes(prop.name))).length;
 	const scriptText = [descriptor.script?.content, descriptor.scriptSetup?.content].filter(Boolean).join("\n");
-	const fallthroughUnverifiable = Boolean(descriptor.script) || descriptor.scriptSetup?.src !== void 0 || /\b(?:defineOptions|defineProps|inheritAttrs)\b/.test(descriptor.scriptSetup?.content ?? "");
 	let scriptImportsUnverifiable = false;
+	const scriptImports = [];
+	let setupAnalysis;
+	let scriptUsesCssModule = false;
+	let scriptHasDynamicImport = false;
+	const scriptVueReferences = [];
+	const scriptVueGlobPatterns = [];
+	let scriptVueGlobUnverifiable = false;
 	const styleImports = [descriptor.script, descriptor.scriptSetup].flatMap((script) => {
 		if (!script) return [];
-		if (script.src || ![
-			void 0,
-			"js",
-			"jsx",
-			"ts",
-			"tsx"
-		].includes(script.lang)) {
+		if (script.src || !SUPPORTED_SCRIPT_LANGUAGES.has(script.lang)) {
 			scriptImportsUnverifiable = true;
 			return [];
 		}
 		try {
-			return staticImports(`${path}.${script.lang ?? "js"}`, script.content);
+			const analysis = sourceAnalysis(`${path}.${script.lang ?? "js"}`, script.content);
+			if (script === descriptor.scriptSetup) setupAnalysis = analysis;
+			if (analysis.usesCssModule || analysis.hasUnboundUseCssModule) scriptUsesCssModule = true;
+			if (analysis.hasDynamicImport) scriptHasDynamicImport = true;
+			scriptImports.push(...analysis.imports);
+			scriptVueReferences.push(...analysis.imports.filter((record) => !record.typeOnly).map((record) => record.specifier));
+			scriptVueGlobPatterns.push(...analysis.vueGlobPatterns);
+			if (analysis.vueGlobUnverifiable) scriptVueGlobUnverifiable = true;
+			return analysis.staticImports;
 		} catch {
 			scriptImportsUnverifiable = true;
 			return [];
 		}
 	});
-	let componentImports = [];
-	if (descriptor.scriptSetup && !descriptor.scriptSetup.src && [
-		void 0,
-		"js",
-		"jsx",
-		"ts",
-		"tsx"
-	].includes(descriptor.scriptSetup.lang)) try {
-		componentImports = staticImportBindings(`${path}.${descriptor.scriptSetup.lang ?? "js"}`, descriptor.scriptSetup.content);
-	} catch {
-		componentImports = [];
-	}
+	const fallthroughUnverifiable = Boolean(descriptor.script) || descriptor.scriptSetup?.src !== void 0 || Boolean(descriptor.scriptSetup) && !setupAnalysis || setupAnalysis?.hasVueFallthroughMacro === true;
+	const componentImports = setupAnalysis?.defaultImports ?? [];
 	const offsets = utf8OffsetMap(source, [
 		...warnings.flatMap((warning) => [warning.start, warning.end]),
+		...styleRanges.flatMap((range) => [range.start, range.end]),
 		...[
 			...blocks,
 			...unscopedBlocks,
@@ -1194,15 +1772,11 @@ function analyzeVueSource(compiler, path, source) {
 		}
 	});
 	return {
-		warnings: warnings.map((warning) => ({
-			...warning,
-			start: offset(warning.start),
-			end: offset(warning.end)
-		})),
+		...byteRanges(offset),
 		blocks: blocks.map(toByteBlock),
 		unscopedBlocks: unscopedBlocks.map(toByteBlock),
 		moduleBlocks: moduleBlocks.map(toByteBlock),
-		moduleClosureBroken: moduleSiblingUnsupported || scriptImportsUnverifiable || /\$style|useCssModule/.test([...state.expressionTexts, scriptText].join("\n")),
+		moduleClosureBroken: moduleSiblingUnsupported || scriptImportsUnverifiable || scriptUsesCssModule || state.moduleClosureBroken || state.referencesUseCssModule && setupAnalysis?.definesRootUseCssModule !== true || (setupAnalysis?.useCssModuleLocals ?? []).some((name) => state.expressionReferences.has(name)),
 		htmlElements: state.elements.map(toByteSite),
 		componentSites: state.components.map(toByteSite),
 		rootStarts: template.ast.children.filter((node) => node.type === NODE_ELEMENT).map((node) => offsets.get(node.loc.start.offset)),
@@ -1210,7 +1784,13 @@ function analyzeVueSource(compiler, path, source) {
 		rootFragment: template.ast.children.filter((node) => node.type === NODE_ELEMENT || node.type === NODE_INTERPOLATION || node.type === NODE_TEXT && node.content?.trim?.() !== "").length !== 1,
 		scriptText,
 		scriptStyleImports: [...new Set(styleImports)],
+		scriptImports,
 		scriptImportsUnverifiable,
+		scriptHasDynamicImport,
+		scriptVueReferences,
+		scriptVueGlobPatterns,
+		scriptVueGlobUnverifiable,
+		hasOpaqueStyleBlocks: opaqueStyleBlocks,
 		styleBlockImports: styleBlockImports.map((entry) => ({
 			...entry,
 			start: offset(entry.start),
@@ -1247,27 +1827,36 @@ function visitTemplateNode(source, node, state) {
 		let moduleBinding;
 		for (const prop of node.props ?? []) {
 			if (prop.type !== PROP_DIRECTIVE) continue;
+			const expression = prop.exp?.content ? prop.name === "on" ? templateHandler(prop.exp.content) : templateExpression(state.expressionPath, prop.exp.content) : void 0;
+			if (prop.exp?.content && !expression) state.moduleClosureBroken = true;
 			let provenModuleExpression = false;
 			if (prop.name === "bind") {
 				if (!prop.arg || !prop.arg.isStatic) classOpaque = true;
 				else if (prop.arg.content === "class") {
-					const member = node.tagType === TAG_ELEMENT && prop.exp ? /^\s*\$style\s*\.\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*$/.exec(prop.exp.content) : void 0;
+					const member = node.tagType === TAG_ELEMENT ? expression?.vueModuleMember : void 0;
 					if (member && !moduleBinding) {
 						moduleBinding = {
-							name: member[1],
+							name: member,
 							start: attributeRemovalStart(source, node, prop),
 							end: prop.loc.end.offset
 						};
 						provenModuleExpression = true;
 					} else {
-						const value = staticClassBinding(prop);
+						const value = expression?.staticString ?? void 0;
 						if (value === void 0) classOpaque = true;
 						else bindingClasses.push(...value.split(/[\t\n\f\r ]+/).filter(Boolean));
 					}
 				} else if (prop.arg.content === "id") classOpaque = true;
 			}
-			if (!provenModuleExpression && prop.exp?.content) state.expressionTexts.push(prop.exp.content);
-			if (prop.arg && !prop.arg.isStatic && prop.arg.content) state.expressionTexts.push(prop.arg.content);
+			if (!provenModuleExpression && expression?.usesCssModule) state.moduleClosureBroken = true;
+			if (expression?.referencesUseCssModule) state.referencesUseCssModule = true;
+			for (const name of expression?.references ?? []) state.expressionReferences.add(name);
+			if (prop.arg && !prop.arg.isStatic && prop.arg.content) {
+				const argExpression = templateExpression(state.expressionPath, prop.arg.content);
+				state.moduleClosureBroken ||= argExpression?.usesCssModule ?? true;
+				state.referencesUseCssModule ||= argExpression?.referencesUseCssModule ?? false;
+				for (const name of argExpression?.references ?? []) state.expressionReferences.add(name);
+			}
 			if (prop.name === "html") state.vHtml = true;
 		}
 		if (classOpaque) state.dynamic = true;
@@ -1281,7 +1870,12 @@ function visitTemplateNode(source, node, state) {
 		if (node.tagType === TAG_COMPONENT) state.components.push(element);
 		else if (node.tagType === TAG_ELEMENT) state.elements.push(element);
 	}
-	if (node.type === NODE_INTERPOLATION && node.content?.content) state.expressionTexts.push(node.content.content);
+	if (node.type === NODE_INTERPOLATION && node.content?.content) {
+		const interpolation = templateExpression(state.expressionPath, node.content.content);
+		state.moduleClosureBroken ||= interpolation?.usesCssModule ?? true;
+		state.referencesUseCssModule ||= interpolation?.referencesUseCssModule ?? false;
+		for (const name of interpolation?.references ?? []) state.expressionReferences.add(name);
+	}
 	for (const child of node.children ?? []) visitTemplateNode(source, child, state);
 }
 function attributeRemovalStart(source, node, prop) {
@@ -1290,10 +1884,23 @@ function attributeRemovalStart(source, node, prop) {
 	while (start > node.loc.start.offset + 1 && /\s/.test(source[start - 1])) start -= 1;
 	return /[\r\n]/.test(source.slice(start, attributeStart)) ? attributeStart : start;
 }
-function staticClassBinding(prop) {
-	if (!prop.exp) return void 0;
+function templateExpression(path, source) {
+	try {
+		return expressionAnalysis(path, source);
+	} catch {
+		return;
+	}
+}
+function templateHandler(source) {
 	try {
-		return staticStringExpression("Component.js", prop.exp.content) ?? void 0;
+		const analysis = sourceAnalysis("Component.handler.ts", `async function handler($event) { ${source} }`);
+		return {
+			staticString: null,
+			vueModuleMember: null,
+			usesCssModule: analysis.usesCssModule,
+			referencesUseCssModule: analysis.hasUnboundUseCssModule,
+			references: analysis.unboundReferences
+		};
 	} catch {
 		return;
 	}
@@ -1309,7 +1916,7 @@ function templateSite(source, node, bindingClasses, classOpaque, state) {
 	}
 	const matchClasses = bindingClasses.length ? [...classAttribute?.value.split(/[\t\n\f\r ]+/).filter(Boolean) ?? [], ...bindingClasses] : void 0;
 	if (!classAttribute && (bindingClasses.length > 0 || !classOpaque && (node.tagType === TAG_COMPONENT || idAttribute))) {
-		const insertion = classInsertionOffset(source, node);
+		const insertion = nodeClassInsertionOffset(source, node);
 		if (insertion === void 0) state.dynamic = true;
 		else classAttribute = {
 			value: "",
@@ -1340,22 +1947,11 @@ function literalAttribute(source, node, name) {
 		end: end - 1
 	};
 }
-function classInsertionOffset(source, node) {
+function nodeClassInsertionOffset(source, node) {
 	const propsEnd = Math.max(node.loc.start.offset + 1 + node.tag.length, ...(node.props ?? []).map((prop) => prop.loc.end.offset));
 	const tagEnd = source.indexOf(">", propsEnd);
 	if (tagEnd < 0) return void 0;
-	let offset = tagEnd;
-	if (source[offset - 1] === "/") offset -= 1;
-	while (offset > node.loc.start.offset && /\s/.test(source[offset - 1])) offset -= 1;
-	return offset;
-}
-function toByteWarnings(source, warnings) {
-	const offsets = utf8OffsetMap(source, warnings.flatMap((warning) => [warning.start, warning.end]));
-	return warnings.map((warning) => ({
-		...warning,
-		start: offsets.get(warning.start) ?? warning.start,
-		end: offsets.get(warning.end) ?? warning.end
-	}));
+	return classInsertionOffset(source, node.loc.start.offset, tagEnd);
 }
 //#endregion
 //#region src/plan/vue.ts
@@ -1375,12 +1971,12 @@ function vueReferenceTarget(importer, reference, vuePaths) {
 		join(target, "index.vue")
 	].find((path) => vuePaths.has(path));
 }
-function vueLiteralTargets(file, vuePaths) {
-	return new Set([...file.source.matchAll(/(["'`])([^"'`\r\n]+)\1/g)].flatMap((match) => {
-		if (/[?*[\]{}]/.test(match[2]) && (match[2].includes("vue") || isLocalVueReference(match[2]))) return [...vuePaths];
-		const target = vueReferenceTarget(file.path, match[2], vuePaths);
+function vueGlobTargets(importer, patterns, vuePaths) {
+	return new Set(patterns.flatMap((pattern) => {
+		if (/[?*[\]{}]/.test(pattern)) return pattern.includes("vue") || isLocalVueReference(pattern) ? [...vuePaths] : [];
+		const target = vueReferenceTarget(importer, pattern, vuePaths);
 		if (target) return [target];
-		return match[2].includes(".vue") ? [...vuePaths] : [];
+		return pattern.includes(".vue") ? [...vuePaths] : [];
 	}));
 }
 function normalizedVueTag(value) {
@@ -1427,28 +2023,48 @@ function buildVueComponentGraph(ownedVue, sourceFiles, analyses, { styleSources,
 		if (analysis.componentsOpen) for (const target of vuePaths) callerOpen.add(target);
 	}
 	for (const file of sourceFiles) {
+		if (extname(file.path) === ".html") continue;
 		let references;
+		let vueReferences;
 		let blockReferences = [];
+		let hasDynamicImport = false;
+		let vueGlobPatterns = [];
+		let vueGlobUnverifiable = false;
 		if (extname(file.path) === ".vue") {
 			const fileAnalysis = analyses.get(file.path);
 			if (fileAnalysis && !fileAnalysis.retained) {
 				references = fileAnalysis.scriptStyleImports;
+				vueReferences = fileAnalysis.scriptVueReferences;
 				blockReferences = fileAnalysis.styleBlockImports.map((entry) => entry.reference);
-			} else references = [];
+				hasDynamicImport = fileAnalysis.scriptHasDynamicImport || fileAnalysis.scriptImportsUnverifiable;
+				vueGlobPatterns = fileAnalysis.scriptVueGlobPatterns;
+				vueGlobUnverifiable = fileAnalysis.scriptVueGlobUnverifiable;
+			} else {
+				references = [];
+				vueReferences = [];
+				hasDynamicImport = true;
+			}
 		} else try {
-			references = staticImports(file.path, file.source);
+			const analysis = sourceAnalysis(file.path, file.source);
+			references = analysis.staticImports;
+			vueReferences = analysis.imports.filter((record) => !record.typeOnly).map((record) => record.specifier);
+			hasDynamicImport = analysis.hasDynamicImport;
+			vueGlobPatterns = analysis.vueGlobPatterns;
+			vueGlobUnverifiable = analysis.vueGlobUnverifiable;
 		} catch {
 			references = [];
+			vueReferences = [];
+			hasDynamicImport = true;
 		}
-		if (/\bimport\s*\(/.test(file.source) || references.some((reference) => !stylesheetReference.test(reference) && isLocalVueReference(reference) && couldResolveToVue(reference) && !vueReferenceTarget(file.path, reference, vuePaths))) for (const target of vuePaths) callerOpen.add(target);
+		if (hasDynamicImport || vueGlobUnverifiable || vueReferences.some((reference) => !stylesheetReference.test(reference) && isLocalVueReference(reference) && couldResolveToVue(reference) && !vueReferenceTarget(file.path, reference, vuePaths))) for (const target of vuePaths) callerOpen.add(target);
 		const resolvesOwned = (reference) => stylesheetReferenceTargets(file.path, reference, styleSources).some((path) => pathOwners.get(path) === packageRoot);
 		if (pathOwners.get(file.path) === packageRoot && (references.some((reference) => stylesheetReference.test(reference) && (!reference.startsWith(".") || !resolvesOwned(reference))) || blockReferences.some((reference) => !resolvesOwned(reference)))) unresolvedStyleImport = true;
-		const imported = new Set(references.flatMap((reference) => {
+		const imported = new Set(vueReferences.flatMap((reference) => {
 			const target = vueReferenceTarget(file.path, reference, vuePaths);
 			return target ? [target] : [];
 		}));
 		for (const target of imported) if (extname(file.path) !== ".vue" || !analyses.get(file.path)?.setupImports?.has(target)) callerOpen.add(target);
-		for (const target of vueLiteralTargets(file, vuePaths)) if (!imported.has(target)) callerOpen.add(target);
+		for (const target of vueGlobTargets(file.path, vueGlobPatterns, vuePaths)) if (!imported.has(target)) callerOpen.add(target);
 	}
 	return {
 		callers,
@@ -1456,15 +2072,16 @@ function buildVueComponentGraph(ownedVue, sourceFiles, analyses, { styleSources,
 		unresolvedStyleImport
 	};
 }
-function vueWarningsOnlyResult(preparedVue) {
-	if (preparedVue.warnings.length === 0) return {};
+function vueWarningsOnlyResult(preparedVue, extraWarnings = []) {
+	const warnings = [...preparedVue.warnings, ...extraWarnings];
+	if (warnings.length === 0) return {};
 	return { plan: {
 		files: [],
 		deletedFiles: [],
 		unlinkedFiles: [],
 		candidates: [],
 		rules: [],
-		warnings: preparedVue.warnings,
+		warnings,
 		convertedRules: 0,
 		retainedRules: 0
 	} };
@@ -1473,6 +2090,7 @@ async function preparePackageVue({ packageRoot, styleCompilers, sourceFiles, sty
 	const none = {
 		files: /* @__PURE__ */ new Map(),
 		stylesheets: [],
+		styleRanges: /* @__PURE__ */ new Map(),
 		stylePaths: /* @__PURE__ */ new Set(),
 		unscopedPaths: /* @__PURE__ */ new Set(),
 		warnings: [],
@@ -1545,13 +2163,17 @@ async function preparePackageVue({ packageRoot, styleCompilers, sourceFiles, sty
 		pathOwners,
 		packageRoot
 	});
-	const generatesSelectors = (text) => /#\{|@\{|&[\w-]/.test(text);
 	const vueShadowCss = [];
 	const vueShadowModuleCss = [];
 	let vueShadowUnverifiable = vueGraph.unresolvedStyleImport;
 	for (const [path, source] of styleSources) {
 		if (pathOwners.get(path) !== packageRoot) continue;
-		if (isPreprocessorPath(path) && generatesSelectors(source)) {
+		try {
+			if (stylesheetAnalysis(path, source).selectorsUnverifiable) {
+				vueShadowUnverifiable = true;
+				continue;
+			}
+		} catch {
 			vueShadowUnverifiable = true;
 			continue;
 		}
@@ -1561,21 +2183,23 @@ async function preparePackageVue({ packageRoot, styleCompilers, sourceFiles, sty
 			source
 		});
 	}
-	for (const file of sourceFiles) if (extname(file.path) === ".html" && pathOwners.get(file.path) === packageRoot && /<style/i.test(file.source)) vueShadowUnverifiable = true;
+	for (const file of sourceFiles) if (extname(file.path) === ".html" && pathOwners.get(file.path) === packageRoot) try {
+		if (parseHtmlSource(file.path, file.source).hasStyle) vueShadowUnverifiable = true;
+	} catch {
+		vueShadowUnverifiable = true;
+	}
 	for (const file of ownedVue) {
 		const analysis = analysisOf(file.path);
 		if (analysis.retained) {
-			if (/<style/i.test(file.source)) vueShadowUnverifiable = true;
+			if (analysis.styleRanges.length > 0) vueShadowUnverifiable = true;
 			continue;
 		}
 		if (analysis.escapeUnverifiable || analysis.scriptImportsUnverifiable) vueShadowUnverifiable = true;
-		for (const text of analysis.shadowPreprocessorTexts) if (generatesSelectors(text)) vueShadowUnverifiable = true;
-		else vueShadowCss.push({
+		for (const text of analysis.shadowPreprocessorTexts) vueShadowCss.push({
 			path: file.path,
 			source: text
 		});
-		for (const text of analysis.unscopedShadowPreprocessorTexts) if (generatesSelectors(text)) vueShadowUnverifiable = true;
-		else vueShadowCss.push({
+		for (const text of analysis.unscopedShadowPreprocessorTexts) vueShadowCss.push({
 			path: file.path,
 			source: text,
 			migratingUnscoped: true
@@ -1589,7 +2213,7 @@ async function preparePackageVue({ packageRoot, styleCompilers, sourceFiles, sty
 			migratingUnscoped: true
 		})), ...analysis.blocks.map((block) => ({
 			path: file.path,
-			source: block.analysisSource ?? block.content,
+			source: block.shadowSource ?? block.analysisSource ?? block.content,
 			scoped: true
 		})));
 		vueShadowModuleCss.push(...analysis.shadowModuleCssTexts, ...analysis.moduleBlocks.map((block) => block.analysisSource ?? block.content));
@@ -1630,7 +2254,7 @@ async function preparePackageVue({ packageRoot, styleCompilers, sourceFiles, sty
 		for (const path of importedStyles) {
 			stylePaths.add(path);
 			if (extname(path) !== ".css") continue;
-			for (const imported of cssImports(styleSources.get(path) ?? "")) {
+			for (const imported of cssImports(path, styleSources.get(path) ?? "")) {
 				if (imported.media) continue;
 				for (const target of stylesheetReferenceTargets(path, imported.href, styleSources)) if (pathOwners.get(target) === packageRoot) importedStyles.add(target);
 			}
@@ -1715,6 +2339,19 @@ async function preparePackageVue({ packageRoot, styleCompilers, sourceFiles, sty
 				message
 			});
 		}
+		const allStyleBlocks = [
+			...analysis.blocks,
+			...analysis.moduleBlocks,
+			...analysis.unscopedBlocks
+		];
+		let vueAtRuleIdentities;
+		if (analysis.hasOpaqueStyleBlocks) vueAtRuleIdentities = null;
+		else try {
+			const registrations = allStyleBlocks.map((block) => stylesheetAnalysis(`${file.path}.${block.analysisSource ? "css" : block.syntax}`, block.analysisSource ?? block.content));
+			vueAtRuleIdentities = registrations.some((entry) => entry.globalAtRulesUnverifiable) ? null : registrations.flatMap((entry) => entry.globalAtRuleIdentities);
+		} catch {
+			vueAtRuleIdentities = null;
+		}
 		const vueBlocks = migrateUnscoped ? analysis.unscopedBlocks : analysis.blocks;
 		if (vueBlocks.length === 0 && !migrateModule) continue;
 		const vueRetention = migrateUnscoped ? void 0 : retention;
@@ -1722,19 +2359,20 @@ async function preparePackageVue({ packageRoot, styleCompilers, sourceFiles, sty
 		if (migrateModule) stylesheets.push({
 			cssPath: file.path,
 			cssSource: file.source,
-			cssModuleId: normalizedRelativePath(packageRoot, file.path),
+			cssModuleId: normalizedRelativePath(workspaceRoot, file.path),
 			syntax: "css",
 			isModule: true,
 			vueBlocks: analysis.moduleBlocks,
 			vueModule: true,
 			vueShadowCss: shadowCss,
 			vueShadowModuleCss,
-			vueShadowUnverifiable
+			vueShadowUnverifiable,
+			vueAtRuleIdentities
 		});
 		if (vueBlocks.length > 0) stylesheets.push({
 			cssPath: file.path,
 			cssSource: file.source,
-			cssModuleId: normalizedRelativePath(packageRoot, file.path),
+			cssModuleId: normalizedRelativePath(workspaceRoot, file.path),
 			syntax: "css",
 			isModule: !vueRetention,
 			vueBlocks,
@@ -1742,7 +2380,8 @@ async function preparePackageVue({ packageRoot, styleCompilers, sourceFiles, sty
 			vueUnscoped: migrateUnscoped,
 			vueShadowCss: vueRetention ? void 0 : shadowCss,
 			vueShadowModuleCss: vueRetention ? void 0 : vueShadowModuleCss,
-			vueShadowUnverifiable: vueRetention ? void 0 : vueShadowUnverifiable
+			vueShadowUnverifiable: vueRetention ? void 0 : vueShadowUnverifiable,
+			vueAtRuleIdentities
 		});
 	}
 	for (const file of ownedVue) {
@@ -1750,24 +2389,28 @@ async function preparePackageVue({ packageRoot, styleCompilers, sourceFiles, sty
 		if (analysis.retained) continue;
 		const elements = elementsByFile.get(file.path) ?? [];
 		const contextPaths = [...new Set(elements.flatMap((element) => element.cssPaths))];
-		if (contextPaths.length === 0) continue;
-		await rejectSymlinkTarget(file.path, packageRoot);
+		if (contextPaths.length > 0) await rejectSymlinkTarget(file.path, packageRoot);
 		files.set(file.path, {
 			...file,
-			htmlElements: elements,
-			htmlStylesheets: contextPaths.map((cssPath) => ({
-				cssPath,
-				variants: [],
-				direct: cssPath === file.path,
-				analyzable: true
-			})),
-			htmlReferencesSafe: !analysis.dynamic,
-			htmlScriptText: analysis.scriptText
+			...contextPaths.length > 0 ? {
+				htmlElements: elements,
+				htmlStylesheets: contextPaths.map((cssPath) => ({
+					cssPath,
+					variants: [],
+					direct: cssPath === file.path,
+					analyzable: true
+				})),
+				htmlReferencesSafe: !analysis.dynamic,
+				htmlScriptText: analysis.scriptText
+			} : {},
+			sourceImports: analysis.scriptImports,
+			sourceImportsUnverifiable: analysis.scriptImportsUnverifiable
 		});
 	}
 	return {
 		files,
 		stylesheets,
+		styleRanges: new Map([...analyses].map(([path, analysis]) => [path, analysis.styleRanges])),
 		stylePaths,
 		unscopedPaths,
 		warnings,
@@ -1783,7 +2426,7 @@ async function verifySnapshots(snapshots) {
 		const read = reads[index];
 		if (read.status === "rejected") {
 			const error = read.reason;
-			const detail = errorCode(error) ?? (error instanceof Error ? error.message : String(error));
+			const detail = errorCode(error) ?? errorMessage(error);
 			throw new Error(`Source changed after planning: ${path} (${detail})`);
 		}
 		if (read.value !== before) throw new Error(`Source changed after planning: ${path}`);
@@ -1818,6 +2461,38 @@ async function writeChanges(changes, deletions) {
 }
 //#endregion
 //#region src/index.ts
+function indexWarningPositions(source, offsets, unicodeSeparatorsAreNewlines, formFeedIsNewline, initial = {
+	line: 1,
+	column: 1
+}) {
+	const targets = [...offsets].sort((left, right) => left - right);
+	const positions = /* @__PURE__ */ new Map();
+	let target = 0;
+	let byte = 0;
+	let { line, column } = initial;
+	let previousWasCarriageReturn = false;
+	const record = () => {
+		while (targets[target] === byte) {
+			positions.set(byte, {
+				line,
+				column
+			});
+			target += 1;
+		}
+	};
+	record();
+	for (const character of source) {
+		byte += Buffer.byteLength(character);
+		while ((targets[target] ?? Infinity) < byte) target += 1;
+		if (character === "\r" || character === "\n" && !previousWasCarriageReturn || unicodeSeparatorsAreNewlines && (character === "\u2028" || character === "\u2029") || formFeedIsNewline && character === "\f") {
+			line += 1;
+			column = 1;
+		} else if (character !== "\n") column += character.length;
+		previousWasCarriageReturn = character === "\r";
+		record();
+	}
+	return positions;
+}
 async function migrate(options = {}) {
 	if (options.styleFile && options.workspaces) throw new TypeError("styleFile cannot be combined with workspaces");
 	if (options.tailwindCss && options.workspaces) throw new TypeError("tailwindCss cannot be combined with workspaces");
@@ -1835,7 +2510,13 @@ async function migrate(options = {}) {
 		Promise.all(stylePaths.map(async (path) => [path, await snapshotFile(snapshots, path)])).then((entries) => new Map(entries)),
 		Promise.all(sourcePaths.map(async (path) => {
 			const source = await readFile(path, "utf8");
-			const mayReferenceModule = extname(path) !== ".html" || /<link\b/i.test(source);
+			const mayReferenceModule = extname(path) !== ".html" || (() => {
+				try {
+					return parseHtmlSource(path, source).links.length > 0;
+				} catch {
+					return /<link\b/i.test(source);
+				}
+			})();
 			if (!scope.targetable.has(path) && !mayReferenceModule) return void 0;
 			return {
 				path,
@@ -1847,21 +2528,35 @@ async function migrate(options = {}) {
 	const sourceFiles = sourceCandidates.flatMap((file) => file ? [file] : []);
 	if (explicitStyle && isStylesheetPath(explicitStyle) && !styleSources.has(explicitStyle)) styleSources.set(explicitStyle, await snapshotFile(snapshots, explicitStyle));
 	if (configuredEntry && !styleSources.has(configuredEntry)) styleSources.set(configuredEntry, await snapshotFile(snapshots, configuredEntry));
+	const vueStyleRanges = /* @__PURE__ */ new Map();
 	const context = {
 		...scope,
 		options,
 		snapshots,
 		styleSources,
 		sourceFiles,
-		styleDependents: indexStylesheetDependents(styleSources)
+		styleDependents: indexStylesheetDependents(styleSources),
+		vueStyleRanges,
+		entryCatalog: tailwindEntryCatalog(styleSources, scope.pathOwners),
+		ignoredPaths: options.workspaces ? await scannerIgnoredPaths(workspaceRoot, sourceFiles.map((file) => file.path)) : /* @__PURE__ */ new Set()
 	};
 	const failures = [];
 	const plans = [];
+	const prepared = [];
 	for (const packageRoot of selectedPackages) {
-		const result = await planPackage(context, packageRoot);
-		if (result.failure) failures.push(result.failure);
-		else if (result.plan) plans.push(result.plan);
-	}
+		const preparation = await preparePackage(context, packageRoot);
+		if (preparation.failure) failures.push(preparation.failure);
+		else if (preparation.plan) plans.push(preparation.plan);
+		if (preparation.prepared) prepared.push(preparation.prepared);
+	}
+	const groups = /* @__PURE__ */ new Map();
+	for (const preparation of prepared) {
+		const members = groups.get(preparation.tailwind.path) ?? [];
+		members.push(preparation);
+		groups.set(preparation.tailwind.path, members);
+	}
+	for (const [, members] of [...groups].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)) for (const result of await planPreparedGroup(context, members)) if (result.failure) failures.push(result.failure);
+	else if (result.plan) plans.push(result.plan);
 	const originals = new Map([...styleSources, ...sourceFiles.map((file) => [file.path, file.source])]);
 	const { filesByPath, deletedPaths, candidates, rules, warnings, convertedRules, retainedRules } = mergePlans(plans, originals);
 	const changed = [...filesByPath.values()].map((file) => ({
@@ -1880,6 +2575,42 @@ async function migrate(options = {}) {
 		await writeChanges(changed, deleted);
 	}
 	warnings.sort((left, right) => left.file.localeCompare(right.file) || left.start - right.start || left.end - right.end || left.code.localeCompare(right.code));
+	const warningOffsets = /* @__PURE__ */ new Map();
+	for (const warning of warnings) {
+		if (warning.start === 0 && warning.end === 0) continue;
+		const offsets = warningOffsets.get(warning.file) ?? /* @__PURE__ */ new Set();
+		offsets.add(warning.start).add(warning.end);
+		warningOffsets.set(warning.file, offsets);
+	}
+	const warningPositions = new Map([...warningOffsets].flatMap(([file, offsets]) => {
+		const source = snapshots.get(file);
+		if (!source) return [];
+		const extension = extname(file);
+		const javascriptSource = SOURCE_EXTENSIONS.has(extension) && extension !== ".html" && extension !== ".vue";
+		const styleRanges = vueStyleRanges.get(file) ?? [];
+		const defaultOffsets = new Set(offsets);
+		for (const range of styleRanges) defaultOffsets.add(range.start);
+		const defaultPositions = indexWarningPositions(source, defaultOffsets, javascriptSource, isStylesheetPath(file));
+		const bytes = Buffer.from(source);
+		const sortedOffsets = [...offsets].sort((left, right) => left - right);
+		const stylePositions = /* @__PURE__ */ new Map();
+		let offsetIndex = 0;
+		for (const range of styleRanges) {
+			while ((sortedOffsets[offsetIndex] ?? Infinity) < range.start) offsetIndex += 1;
+			const relativeOffsets = /* @__PURE__ */ new Set();
+			while ((sortedOffsets[offsetIndex] ?? Infinity) <= range.end) {
+				relativeOffsets.add(sortedOffsets[offsetIndex] - range.start);
+				offsetIndex += 1;
+			}
+			const initial = defaultPositions.get(range.start);
+			if (!initial) continue;
+			for (const [offset, position] of indexWarningPositions(bytes.subarray(range.start, range.end).toString(), relativeOffsets, false, true, initial)) stylePositions.set(range.start + offset, position);
+		}
+		return [[file, {
+			default: defaultPositions,
+			style: stylePositions
+		}]];
+	}));
 	failures.sort((left, right) => left.package.localeCompare(right.package));
 	return {
 		changedFiles,
@@ -1891,15 +2622,29 @@ async function migrate(options = {}) {
 			file: normalizedRelativePath(cwd, rule.file)
 		})),
 		candidates: [...candidates].sort(),
-		warnings: warnings.map((warning) => ({
-			...warning,
-			file: normalizedRelativePath(cwd, warning.file)
-		})),
+		warnings: warnings.map((warning) => {
+			const indexed = warningPositions.get(warning.file);
+			const styleFrom = indexed?.style.get(warning.start);
+			const styleTo = indexed?.style.get(warning.end);
+			const located = warning.start !== 0 || warning.end !== 0;
+			const from = located ? styleFrom ?? indexed?.default.get(warning.start) : void 0;
+			const to = located ? styleFrom && styleTo ? styleTo : indexed?.default.get(warning.end) : void 0;
+			return {
+				...warning,
+				...from && to ? {
+					line: from.line,
+					column: from.column,
+					endLine: to.line,
+					endColumn: to.column
+				} : {},
+				file: normalizedRelativePath(cwd, warning.file)
+			};
+		}),
 		failures
 	};
 }
-async function planPackage(context, packageRoot) {
-	const { options, snapshots, workspaceRoot, explicitStyle, configuredEntry, styleSources, sourceFiles, styleDependents, pathOwners, targetable, selectedPackages, scannedPaths } = context;
+async function preparePackage(context, packageRoot) {
+	const { options, snapshots, workspaceRoot, explicitStyle, configuredEntry, styleSources, sourceFiles, styleDependents, pathOwners, targetable, selectedPackages, scannedPaths, vueStyleRanges } = context;
 	const recover = (error, fatal = false) => {
 		if (!options.force || fatal) throw error;
 		return { failure: packageFailure(workspaceRoot, packageRoot, error) };
@@ -1936,25 +2681,96 @@ async function planPackage(context, packageRoot) {
 	} catch (error) {
 		return recover(error, isIntegrityError(error));
 	}
+	for (const [path, preparedRanges] of preparedVue.styleRanges) {
+		const ranges = vueStyleRanges.get(path) ?? [];
+		ranges.push(...preparedRanges);
+		ranges.sort((left, right) => left.start - right.start);
+		vueStyleRanges.set(path, ranges);
+	}
 	if (explicitStyle && extname(explicitStyle) === ".vue" && preparedVue.stylesheets.length === 0 && ![...preparedVue.stylePaths].some((path) => !isStylesheetModule(path))) return vueWarningsOnlyResult(preparedVue);
 	const packageSources = [...sourceFiles.filter((file) => extname(file.path) !== ".html").map((file) => preparedVue.files.get(file.path) ?? file), ...preparedHtml.files];
 	const ownedStyles = [...styleSources.keys()].filter((path) => pathOwners.get(path) === packageRoot && (targetable.has(path) || preparedHtml.stylePaths.has(path) || preparedVue.stylePaths.has(path)));
 	if (ownedStyles.length === 0 && preparedVue.stylesheets.length === 0) return vueWarningsOnlyResult(preparedVue);
 	let tailwindPath;
 	let tailwindEntries;
-	try {
-		({path: tailwindPath, entries: tailwindEntries} = resolveTailwindEntry(ownedStyles, styleSources, configuredEntry));
-	} catch (error) {
-		return recover(error);
+	let entryOwner = packageRoot;
+	let sharedProofs;
+	const ownEntries = findTailwindEntries(ownedStyles, styleSources);
+	if (ownEntries.length === 0 && configuredEntry === void 0 && options.workspaces && options.extractMediaQueries !== false) {
+		let packageJson = {};
+		try {
+			const rawPackageJson = snapshots.get(join(packageRoot, "package.json"));
+			if (rawPackageJson !== void 0) {
+				const parsed = JSON.parse(rawPackageJson);
+				if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) packageJson = { ...parsed };
+			}
+		} catch (error) {
+			return recover(error);
+		}
+		const ancestors = selectedPackages.filter((root) => root !== packageRoot && isWithin(root, packageRoot)).sort((left, right) => right.length - left.length);
+		for (const ancestor of ancestors) {
+			const proven = [];
+			for (const candidate of context.entryCatalog.get(ancestor) ?? []) {
+				const proofs = proveSharedEntry({
+					packageRoot,
+					entry: candidate,
+					entrySource: styleSources.get(candidate) ?? "",
+					styleSources,
+					packageSources,
+					owned: (path) => pathOwners.get(path) === packageRoot,
+					writable: (path) => targetable.has(path) && pathOwners.get(path) === packageRoot,
+					packageJson,
+					ignoredPaths: context.ignoredPaths
+				});
+				if (proofs) proven.push({
+					entry: candidate,
+					proofs
+				});
+			}
+			if (proven.length > 1) return recover(/* @__PURE__ */ new Error("Multiple proven ancestor Tailwind entries were found. Pass --tailwind-css."));
+			if (proven.length === 1) {
+				[{entry: tailwindPath, proofs: sharedProofs}] = proven;
+				entryOwner = ancestor;
+				break;
+			}
+		}
+	}
+	if (sharedProofs && tailwindPath !== void 0) tailwindEntries = [];
+	else {
+		tailwindEntries = ownEntries;
+		try {
+			tailwindPath = selectTailwindEntry(ownEntries, configuredEntry);
+		} catch (error) {
+			return recover(error);
+		}
 	}
 	const excludedEntries = /* @__PURE__ */ new Set([...tailwindEntries, tailwindPath]);
 	const explicitCss = explicitStyle && extname(explicitStyle) !== ".vue" ? explicitStyle : void 0;
-	const targets = explicitCss ? [explicitCss] : explicitStyle ? [...preparedVue.stylePaths].filter((path) => !isStylesheetModule(path) && !excludedEntries.has(path)) : ownedStyles.filter((path) => !excludedEntries.has(path) && !preparedHtml.generatedPaths.has(path) && (!isPreprocessorPath(path) || preparedHtml.stylePaths.has(path) || packageSources.some((file) => sourceReferencesStyle(file, path))));
+	const targets = explicitCss ? [explicitCss] : explicitStyle ? [...preparedVue.stylePaths].filter((path) => !isStylesheetModule(path) && !excludedEntries.has(path)) : ownedStyles.filter((path) => !excludedEntries.has(path) && !preparedHtml.generatedPaths.has(path) && (!isPreprocessorPath(path) || preparedHtml.stylePaths.has(path) || preparedVue.stylePaths.has(path) || packageSources.some((file) => importsStylesheet(file, path))));
 	if (targets.length === 0 && preparedVue.stylesheets.length === 0) return vueWarningsOnlyResult(preparedVue);
 	if (targets.some((path) => excludedEntries.has(path))) throw new Error("The Tailwind CSS entry cannot be migrated.");
+	const proofWarnings = [];
+	const unprovenFlow = (path) => ({
+		code: "unproven-shared-entry-flow",
+		file: path,
+		start: 0,
+		end: 0,
+		message: "A consumer flow could not be proven to load the shared Tailwind entry, so the stylesheet is retained."
+	});
+	const provenTargets = sharedProofs ? targets.filter((path) => {
+		const proven = sharedProofs.provenStyle(packageSources.filter((file) => importsStylesheet(file, path) || (file.htmlStylesheets ?? []).some((linked) => linked.cssPath === path)));
+		if (!proven) proofWarnings.push(unprovenFlow(path));
+		return proven;
+	}) : targets;
+	const provenVueStylesheets = sharedProofs ? preparedVue.stylesheets.filter((stylesheet) => {
+		const proven = sharedProofs.provenStyle(packageSources.filter((file) => file.path === stylesheet.cssPath));
+		if (!proven && !proofWarnings.some((warning) => warning.file === stylesheet.cssPath)) proofWarnings.push(unprovenFlow(stylesheet.cssPath));
+		return proven;
+	}) : preparedVue.stylesheets;
+	if (provenTargets.length === 0 && provenVueStylesheets.length === 0) return vueWarningsOnlyResult(preparedVue, proofWarnings);
 	let tailwind;
 	try {
-		tailwind = await loadTailwind(packageRoot, tailwindPath, snapshots, workspaceRoot);
+		tailwind = await loadTailwind(entryOwner, tailwindPath, snapshots, workspaceRoot);
 	} catch (error) {
 		return recover(error, isIntegrityError(error));
 	}
@@ -1969,13 +2785,13 @@ async function planPackage(context, packageRoot) {
 	try {
 		stylesheets = [];
 		const compilerDependents = /* @__PURE__ */ new Map();
-		for (const stylePath of targets.sort()) {
+		for (const stylePath of provenTargets.sort()) {
 			await rejectSymlinkTarget(stylePath, packageRoot);
 			const isPartial = isSassPath(stylePath) && basename(stylePath).startsWith("_");
 			const stylesheet = {
 				cssPath: stylePath,
 				cssSource: styleSources.get(stylePath) ?? "",
-				cssModuleId: normalizedRelativePath(packageRoot, stylePath),
+				cssModuleId: normalizedRelativePath(workspaceRoot, stylePath),
 				cssDependents: styleDependents.get(stylePath) ?? [],
 				syntax: stylesheetSyntax(stylePath),
 				isModule: isStylesheetModule(stylePath),
@@ -2009,125 +2825,405 @@ async function planPackage(context, packageRoot) {
 	} catch (error) {
 		return recover(error, isIntegrityError(error));
 	}
-	stylesheets.push(...preparedVue.stylesheets);
-	const request = {
+	stylesheets.push(...provenVueStylesheets);
+	return { prepared: {
+		packageRoot,
+		preparedHtml,
+		preparedVue,
+		styleCompilers,
+		files,
 		stylesheets,
-		tailwindPath: tailwind.path,
-		tailwindSource: tailwind.css,
-		utilityPrefix: tailwind.designSystem.theme.prefix,
-		themeTokens: tailwind.themeTokens,
-		files
+		tailwind,
+		sharedProofs,
+		warnings: proofWarnings
+	} };
+}
+async function planPreparedGroup(context, members) {
+	const { options, workspaceRoot, targetable } = context;
+	const results = [];
+	let active = [...members].sort((left, right) => {
+		const leftPath = normalizedRelativePath(workspaceRoot, left.packageRoot);
+		const rightPath = normalizedRelativePath(workspaceRoot, right.packageRoot);
+		return leftPath < rightPath ? -1 : leftPath > rightPath ? 1 : 0;
+	});
+	const entry = active[0].tailwind;
+	const recoverGroup = (error, fatal = false) => {
+		if (!options.force || fatal) throw error;
+		for (const member of active) results.push({ failure: packageFailure(workspaceRoot, member.packageRoot, error) });
+		return results;
 	};
-	let plan;
-	try {
-		plan = JSON.parse(planBatchMigration(JSON.stringify(request)));
+	const membersByRoot = new Map(active.map((member) => [member.packageRoot, member]));
+	for (const member of options.extractMediaQueries !== false ? active : []) member.stylesheets = member.stylesheets.filter((stylesheet) => {
+		const proven = member.files.filter((file) => context.pathOwners.get(file.path) !== member.packageRoot && (importsStylesheet(file, stylesheet.cssPath) || (file.htmlStylesheets ?? []).some((linked) => linked.cssPath === stylesheet.cssPath))).every((consumer) => {
+			const consumerRoot = context.pathOwners.get(consumer.path);
+			const consumerMember = consumerRoot === void 0 ? void 0 : membersByRoot.get(consumerRoot);
+			if (consumerMember === void 0) return false;
+			if (consumerMember.sharedProofs === void 0) return true;
+			return consumerMember.sharedProofs.provenConsumer(consumer);
+		});
+		if (!proven) member.warnings.push({
+			code: "unproven-shared-entry-flow",
+			file: stylesheet.cssPath,
+			start: 0,
+			end: 0,
+			message: "A consumer flow could not be proven to load the shared Tailwind entry, so the stylesheet is retained."
+		});
+		return proven;
+	});
+	for (const member of active.filter((remaining) => remaining.stylesheets.length === 0)) if (member.warnings.length > 0) results.push({ plan: {
+		files: [],
+		deletedFiles: [],
+		unlinkedFiles: [],
+		candidates: [],
+		rules: [],
+		warnings: [
+			...member.warnings,
+			...member.preparedHtml.warnings,
+			...member.preparedVue.warnings
+		],
+		convertedRules: 0,
+		retainedRules: 0
+	} });
+	active = active.filter((remaining) => remaining.stylesheets.length > 0);
+	if (active.length === 0) return results;
+	const groupWritable = !await entryUnsafe(entry.path, workspaceRoot, targetable);
+	const mediaWarnings = [];
+	let extraction;
+	const collections = [];
+	for (const member of active) try {
+		collections.push(collectMemberMediaConditions(member.stylesheets, entry));
 	} catch (error) {
-		return recover(error, !isRecoverablePlanningError(error));
+		if (!options.force || !isRecoverablePlanningError(error)) throw error;
+		results.push({ failure: packageFailure(workspaceRoot, member.packageRoot, error) });
+		active = active.filter((remaining) => remaining !== member);
+	}
+	if (active.length === 0) return results;
+	let names = extraction?.names;
+	let generated = extraction?.generated ?? [];
+	if (options.extractMediaQueries !== false) if (!groupWritable) {
+		names = {};
+		generated = [];
+		if (collections.some((collection) => collection.components.length > 0)) mediaWarnings.push({
+			code: "media-query-definition-fallback",
+			file: entry.path,
+			start: 0,
+			end: 0,
+			message: "The Tailwind entry could not be edited safely, so media behavior was preserved with arbitrary variants."
+		});
+	} else {
+		try {
+			extraction = planMediaExtraction({
+				collections,
+				tailwind: entry,
+				scannedSources: context.sourceFiles.map((file) => file.source)
+			});
+		} catch (error) {
+			return recoverGroup(error, !isRecoverablePlanningError(error));
+		}
+		names = extraction.names;
+		generated = extraction.generated;
 	}
-	try {
-		plan = replanCompileFailures(tailwind, request, plan);
-	} catch (error) {
-		return recover(error);
+	let plan = {
+		files: [],
+		deletedFiles: [],
+		unlinkedFiles: [],
+		candidates: [],
+		rules: [],
+		warnings: [],
+		convertedRules: 0,
+		retainedRules: 0
+	};
+	let augmented = entry.css;
+	const blocked = /* @__PURE__ */ new Map();
+	finalization: for (;;) {
+		const baseIdentities = new Set(atRuleIdentities(`${entry.path}.group-base.css`, [entry.css, ...entry.graphSources.map((graphSource) => graphSource.source)].join("\n")));
+		const sheets = active.flatMap((member) => member.stylesheets.map((stylesheet) => ({
+			member,
+			stylesheet
+		})));
+		const movable = ({ member, stylesheet }) => member.sharedProofs === void 0 && stylesheet.isModule === true && (stylesheet.syntax === void 0 || stylesheet.syntax === "css") && (stylesheet.vueBlocks === void 0 || stylesheet.vueBlocks.length === 0);
+		for (const sheet of sheets) {
+			if (movable(sheet)) continue;
+			for (const identity of stylesheetAtRuleIdentities(sheet.stylesheet)) baseIdentities.add(identity);
+		}
+		const sheetIdentities = sheets.map((sheet) => movable(sheet) ? new Set(stylesheetAtRuleIdentities(sheet.stylesheet)) : /* @__PURE__ */ new Set());
+		const opaqueVueRegistrations = sheets.some(({ stylesheet }) => stylesheet.vueAtRuleIdentities === null);
+		const movesDisabled = new Set(opaqueVueRegistrations ? sheets.flatMap((sheet, index) => movable(sheet) ? [index] : []) : []);
+		for (const [index, identities] of sheetIdentities.entries()) for (const identity of identities) {
+			if (baseIdentities.has(identity)) movesDisabled.add(index);
+			for (const [other, otherIdentities] of sheetIdentities.entries()) if (other !== index && otherIdentities.has(identity)) {
+				movesDisabled.add(index);
+				movesDisabled.add(other);
+			}
+		}
+		const filesByPath = /* @__PURE__ */ new Map();
+		const contextsByPath = /* @__PURE__ */ new Map();
+		for (const member of active) for (const file of member.files) {
+			if (file.htmlStylesheets !== void 0 && file.htmlStylesheets.length > 0) {
+				const contexts = contextsByPath.get(file.path) ?? [];
+				contexts.push(...file.htmlStylesheets);
+				contextsByPath.set(file.path, contexts);
+			}
+			if (!filesByPath.has(file.path) || context.pathOwners.get(file.path) === member.packageRoot) filesByPath.set(file.path, file);
+		}
+		const files = [...filesByPath.values()].map((file) => {
+			const contexts = contextsByPath.get(file.path);
+			if (contexts === void 0) return file;
+			const seen = /* @__PURE__ */ new Set();
+			const merged = contexts.filter((linked) => {
+				const key = `${linked.cssPath}\0${linked.variants.join(",")}\0${linked.direct}\0${linked.analyzable}`;
+				if (seen.has(key)) return false;
+				seen.add(key);
+				return true;
+			});
+			return {
+				...file,
+				htmlStylesheets: merged
+			};
+		}).sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+		planning: for (;;) {
+			const request = {
+				stylesheets: sheets.map(({ member, stylesheet }, index) => {
+					const rules = blocked.get(index);
+					const movesOff = member.sharedProofs !== void 0 || movesDisabled.has(index);
+					return {
+						...stylesheet,
+						...rules ? { blockedRules: [...rules.values()].map((blockedRule) => blockedRule.ruleId) } : {},
+						...movesOff ? { globalAtRuleMoves: false } : {}
+					};
+				}),
+				tailwindPath: entry.path,
+				tailwindSource: entry.css,
+				utilityPrefix: entry.designSystem.theme.prefix,
+				themeTokens: entry.themeTokens,
+				...names ? { mediaNames: names } : {},
+				...groupWritable ? {} : { entryWritable: false },
+				files
+			};
+			try {
+				plan = JSON.parse(planBatchMigration(JSON.stringify(request)));
+			} catch (error) {
+				return recoverGroup(error, !isRecoverablePlanningError(error));
+			}
+			let composed = entry.css;
+			const plannedEntry = plan.files.findIndex((file) => file.path === entry.path);
+			if (plannedEntry >= 0) {
+				if (!groupWritable) throw new Error(`The planner claimed an unwritable Tailwind entry: ${entry.path}`);
+				composed = plan.files[plannedEntry].source;
+				plan.files.splice(plannedEntry, 1);
+				if (!composed.startsWith(entry.css)) throw new Error(`The planner rewrote the Tailwind entry instead of appending: ${entry.path}`);
+			}
+			const currentExtraction = names !== void 0 ? {
+				names,
+				generated
+			} : void 0;
+			const used = currentExtraction ? usedGeneratedDefinitions(currentExtraction, plan) : [];
+			augmented = currentExtraction ? appendMediaDefinitions(composed, used) : composed;
+			let system;
+			try {
+				system = augmented === entry.css ? entry.designSystem : await entry.loadWith(augmented);
+			} catch (error) {
+				if (isIntegrityError(error)) throw error;
+				if (names !== void 0 && generated.length > 0) {
+					const generatedKeys = new Set(generated.map((definition) => definition.key));
+					names = Object.fromEntries(Object.entries(names).filter(([key]) => !generatedKeys.has(key)));
+					generated = [];
+					continue planning;
+				}
+				return recoverGroup(error);
+			}
+			if (currentExtraction && names !== void 0) {
+				const prefix = entry.designSystem.theme.prefix;
+				const rejected = new Set(used.filter(({ name }) => system.candidatesToCss([probeCandidate(prefix, name)])[0] === null).map(({ key }) => key));
+				if (rejected.size > 0) {
+					names = Object.fromEntries(Object.entries(names).filter(([key]) => !rejected.has(key)));
+					generated = generated.filter(({ key }) => !rejected.has(key));
+					continue planning;
+				}
+			}
+			const failing = invalidCandidates(currentExtraction ? system : entry.designSystem, plan.candidates);
+			if (failing.length > 0) {
+				if (!accumulateBlockedRules(blocked, plan, failing)) throw new Error(`Tailwind did not generate CSS for candidate: ${failing[0]}`);
+				continue planning;
+			}
+			break;
+		}
+		for (const [index, rules] of blocked) {
+			const cssPath = sheets[index].stylesheet.cssPath;
+			for (const { authoredSpan, candidates } of rules.values()) {
+				const failed = [...candidates].sort().map((candidate) => `\`${candidate}\``).join(", ");
+				plan.warnings.push({
+					code: "candidate-compilation-failure",
+					file: cssPath,
+					start: authoredSpan.start,
+					end: authoredSpan.end,
+					message: `Tailwind did not generate CSS for ${failed}, so the rule is retained.`
+				});
+			}
+		}
+		plan.warnings.push(...mediaWarnings);
+		for (const member of active) plan.warnings.push(...member.warnings);
+		removeGroupHtmlLinks(plan, active);
+		const failure = await finishGroupPlan(context, active, plan);
+		if (failure === void 0) break;
+		if (!options.force || failure.fatal) throw failure.error;
+		const failed = failure.member ?? active[0];
+		results.push({ failure: packageFailure(workspaceRoot, failed.packageRoot, failure.error) });
+		active = active.filter((member) => member !== failed);
+		if (active.length === 0) return results;
+		blocked.clear();
+		plan.warnings = [];
+		continue finalization;
+	}
+	const seenWarnings = /* @__PURE__ */ new Set();
+	plan.warnings = plan.warnings.filter((warning) => {
+		const key = `${warning.code}\0${warning.file}\0${warning.start}\0${warning.end}\0${warning.message}`;
+		if (seenWarnings.has(key)) return false;
+		seenWarnings.add(key);
+		return true;
+	});
+	results.push({ plan });
+	if (augmented !== entry.css) results.push({ plan: {
+		files: [{
+			path: entry.path,
+			source: augmented
+		}],
+		deletedFiles: [],
+		unlinkedFiles: [],
+		candidates: [],
+		rules: [],
+		warnings: [],
+		convertedRules: 0,
+		retainedRules: 0
+	} });
+	return results;
+}
+function accumulateBlockedRules(blocked, plan, failing) {
+	let progressed = false;
+	for (const rule of plan.rules) {
+		const failed = rule.candidates.filter((candidate) => failing.includes(candidate));
+		if (failed.length === 0) continue;
+		let rules = blocked.get(rule.stylesheet);
+		if (!rules) blocked.set(rule.stylesheet, rules = /* @__PURE__ */ new Map());
+		const key = `${rule.ruleId.start}-${rule.ruleId.end}`;
+		let blockedRule = rules.get(key);
+		if (!blockedRule) {
+			rules.set(key, blockedRule = {
+				ruleId: rule.ruleId,
+				authoredSpan: rule.authoredSpan,
+				candidates: /* @__PURE__ */ new Set()
+			});
+			progressed = true;
+		}
+		for (const candidate of failed) blockedRule.candidates.add(candidate);
+	}
+	return progressed;
+}
+async function entryUnsafe(entryPath, workspaceRoot, targetable) {
+	if (!targetable.has(entryPath) || !isProjectInput(workspaceRoot, entryPath)) return true;
+	return (await lstat(entryPath)).isSymbolicLink();
+}
+function atRuleIdentities(key, css) {
+	return css.trim() === "" ? [] : stylesheetAnalysis(key, css).globalAtRuleIdentities;
+}
+function stylesheetAtRuleIdentities(stylesheet) {
+	if (stylesheet.vueAtRuleIdentities) return stylesheet.vueAtRuleIdentities;
+	if (stylesheet.vueBlocks) return stylesheet.vueBlocks.flatMap((block, index) => atRuleIdentities(`${stylesheet.cssPath}.${index}.at-rules.${block.analysisSource ? "css" : block.syntax}`, block.analysisSource ?? block.content));
+	return stylesheet.analysisSource === void 0 ? atRuleIdentities(`${stylesheet.cssPath}.at-rules.${stylesheet.syntax ?? "css"}`, stylesheet.cssSource) : atRuleIdentities(`${stylesheet.cssPath}.at-rules.css`, stylesheet.analysisSource);
+}
+async function finishGroupPlan(context, members, plan) {
+	const { snapshots } = context;
+	const membersByRoot = new Map(members.map((member) => [member.packageRoot, member]));
+	const ownerOf = (path) => {
+		const root = context.pathOwners.get(path);
+		return root === void 0 ? void 0 : membersByRoot.get(root);
+	};
+	for (const member of members) {
+		plan.warnings.push(...member.preparedHtml.warnings);
+		plan.warnings.push(...member.preparedVue.warnings);
 	}
-	removeMigratedHtmlLinks(plan, preparedHtml);
-	plan.warnings.push(...preparedHtml.warnings);
-	plan.warnings.push(...preparedVue.warnings);
 	try {
-		for (const file of plan.files.filter((file) => extname(file.path) === ".html")) parseHtmlSource(file.path, file.source);
+		for (const file of plan.files.filter((file) => extname(file.path) === ".html")) try {
+			parseHtmlSource(file.path, file.source);
+		} catch (error) {
+			return {
+				error,
+				member: ownerOf(file.path),
+				fatal: true
+			};
+		}
 		for (const file of plan.files.filter((file) => extname(file.path) === ".vue")) {
-			const vueCompiler = preparedVue.compiler;
+			const owner = ownerOf(file.path);
+			const preparedVue = owner?.preparedVue ?? members[0].preparedVue;
+			const vueCompiler = preparedVue.compiler ?? members[0].preparedVue.compiler;
 			if (!vueCompiler) throw new Error(`No Vue compiler is available to verify ${file.path}`);
-			const includeUnscoped = preparedVue.unscopedPaths.has(file.path);
-			const blocks = verifyVueSource(vueCompiler, file.path, file.source, includeUnscoped);
-			const untouched = /* @__PURE__ */ new Map();
-			for (const block of verifyVueSource(vueCompiler, file.path, snapshots.get(file.path) ?? "", includeUnscoped)) {
-				const key = `${block.syntax}\0${block.content}`;
-				untouched.set(key, (untouched.get(key) ?? 0) + 1);
-			}
-			for (const [index, block] of blocks.entries()) {
-				const key = `${block.syntax}\0${block.content}`;
-				const remaining = untouched.get(key) ?? 0;
-				if (remaining > 0) {
-					untouched.set(key, remaining - 1);
-					continue;
+			try {
+				const includeUnscoped = preparedVue.unscopedPaths.has(file.path);
+				const blocks = verifyVueSource(vueCompiler, file.path, file.source, includeUnscoped);
+				const untouched = /* @__PURE__ */ new Map();
+				for (const block of verifyVueSource(vueCompiler, file.path, snapshots.get(file.path) ?? "", includeUnscoped)) {
+					const key = `${block.syntax}\0${block.content}`;
+					untouched.set(key, (untouched.get(key) ?? 0) + 1);
 				}
-				if (block.syntax === "css") validateCss(block.content);
-				else validateCss((await compileStyleEntry(styleCompilers, packageRoot, `${file.path}.${index}.${block.syntax}`, block.content, { virtualEntry: true })).css);
+				for (const [index, block] of blocks.entries()) {
+					const key = `${block.syntax}\0${block.content}`;
+					const remaining = untouched.get(key) ?? 0;
+					if (remaining > 0) {
+						untouched.set(key, remaining - 1);
+						continue;
+					}
+					if (block.syntax === "css") validateCss(block.content);
+					else {
+						const compilerOwner = owner ?? members[0];
+						validateCss((await compileStyleEntry(compilerOwner.styleCompilers, compilerOwner.packageRoot, `${file.path}.${index}.${block.syntax}`, block.content, { virtualEntry: true })).css);
+					}
+				}
+			} catch (error) {
+				return {
+					error,
+					member: owner,
+					fatal: !isMissingStyleCompilerError(error)
+				};
 			}
 		}
-		for (const stylesheet of stylesheets.filter((stylesheet) => isPreprocessorPath(stylesheet.cssPath))) {
+		for (const member of members) for (const stylesheet of member.stylesheets.filter((stylesheet) => isPreprocessorPath(stylesheet.cssPath))) {
 			const changed = plan.files.find((file) => file.path === stylesheet.cssPath);
 			if (!changed && !plan.deletedFiles.includes(stylesheet.cssPath)) continue;
 			const source = changed?.source ?? "";
-			validateCss((await compileStyleEntry(styleCompilers, packageRoot, stylesheet.cssPath, source)).css);
-		}
-	} catch (error) {
-		return recover(error, !isMissingStyleCompilerError(error));
-	}
-	return { plan };
-}
-function replanCompileFailures(tailwind, request, initialPlan) {
-	let plan = initialPlan;
-	const blockedByStylesheet = /* @__PURE__ */ new Map();
-	while (true) {
-		const failing = invalidCandidates(tailwind, plan.candidates);
-		if (failing.length === 0) break;
-		let progressed = false;
-		for (const rule of plan.rules) {
-			const failed = rule.candidates.filter((candidate) => failing.includes(candidate));
-			if (failed.length === 0) continue;
-			let blocked = blockedByStylesheet.get(rule.stylesheet);
-			if (!blocked) blockedByStylesheet.set(rule.stylesheet, blocked = /* @__PURE__ */ new Map());
-			const key = `${rule.ruleId.start}-${rule.ruleId.end}`;
-			let entry = blocked.get(key);
-			if (!entry) {
-				blocked.set(key, entry = {
-					ruleId: rule.ruleId,
-					authoredSpan: rule.authoredSpan,
-					candidates: /* @__PURE__ */ new Set()
-				});
-				progressed = true;
+			try {
+				validateCss((await compileStyleEntry(member.styleCompilers, member.packageRoot, stylesheet.cssPath, source)).css);
+			} catch (error) {
+				return {
+					error,
+					member,
+					fatal: !isMissingStyleCompilerError(error)
+				};
 			}
-			for (const candidate of failed) entry.candidates.add(candidate);
-		}
-		if (!progressed) throw new Error(`Tailwind did not generate CSS for candidate: ${failing[0]}`);
-		plan = JSON.parse(planBatchMigration(JSON.stringify({
-			...request,
-			stylesheets: request.stylesheets.map((stylesheet, index) => ({
-				...stylesheet,
-				blockedRules: [...blockedByStylesheet.get(index)?.values() ?? []].map((entry) => entry.ruleId)
-			}))
-		})));
-	}
-	for (const [index, blocked] of blockedByStylesheet) {
-		const cssPath = request.stylesheets[index].cssPath;
-		for (const { authoredSpan, candidates } of blocked.values()) {
-			const failed = [...candidates].sort().map((candidate) => `\`${candidate}\``).join(", ");
-			plan.warnings.push({
-				code: "candidate-compilation-failure",
-				file: cssPath,
-				start: authoredSpan.start,
-				end: authoredSpan.end,
-				message: `Tailwind did not generate CSS for ${failed}, so the rule is retained.`
-			});
 		}
+	} catch (error) {
+		return {
+			error,
+			fatal: !isMissingStyleCompilerError(error)
+		};
 	}
-	return plan;
 }
-function removeMigratedHtmlLinks(plan, preparedHtml) {
+function removeGroupHtmlLinks(plan, members) {
 	const unlinked = new Set(plan.unlinkedFiles);
 	const linksByFile = /* @__PURE__ */ new Map();
-	for (const link of preparedHtml.removableLinks) {
-		if (!unlinked.has(link.cssPath)) continue;
-		const links = linksByFile.get(link.filePath) ?? /* @__PURE__ */ new Set();
-		links.add(`${link.href}\0${link.media}`);
-		linksByFile.set(link.filePath, links);
+	const originals = /* @__PURE__ */ new Map();
+	for (const member of members) {
+		for (const link of member.preparedHtml.removableLinks) {
+			if (!unlinked.has(link.cssPath)) continue;
+			const links = linksByFile.get(link.filePath) ?? /* @__PURE__ */ new Set();
+			links.add(`${link.href}\0${link.media}`);
+			linksByFile.set(link.filePath, links);
+		}
+		for (const file of member.preparedHtml.files) if (!originals.has(file.path)) originals.set(file.path, file.source);
 	}
 	for (const [filePath, removable] of linksByFile) {
 		const planned = plan.files.find((file) => file.path === filePath);
-		const original = preparedHtml.files.find((file) => file.path === filePath);
-		if (!original) continue;
-		const source = planned?.source ?? original.source;
+		const source = planned?.source ?? originals.get(filePath);
+		if (source === void 0) continue;
 		const links = parseHtmlSource(filePath, source).links.filter((link) => removable.has(`${link.href}\0${link.media}`)).sort((left, right) => right.tagStart - left.tagStart);
 		let bytes = Buffer.from(source);
 		for (const link of links) bytes = Buffer.concat([bytes.subarray(0, link.tagStart), bytes.subarray(link.tagEnd)]);
@@ -2167,7 +3263,7 @@ function mergePlans(plans, originals) {
 		retainedRules += plan.retainedRules;
 		rules.push(...plan.rules);
 		for (const warning of plan.warnings) {
-			const key = `${warning.code}\0${warning.file}\0${warning.start}\0${warning.end}`;
+			const key = `${warning.code}\0${warning.file}\0${warning.start}\0${warning.end}\0${warning.message}`;
 			if (seenWarnings.has(key)) continue;
 			seenWarnings.add(key);
 			warnings.push(warning);