@weapp-tailwindcss/engine 0.1.0 → 0.1.1

package/dist/{v4-CUw9Iuc5.cjs → v4-DVqsqn8b.cjs}

@@ -27,11 +27,172 @@ let node_process = require("node:process");
 node_process = __toESM(node_process, 1);
 let node_module = require("node:module");
 let node_url = require("node:url");
-let micromatch = require("micromatch");
-micromatch = __toESM(micromatch, 1);
-let node_fs_promises = require("node:fs/promises");
+let node_async_hooks = require("node:async_hooks");
+let node_crypto = require("node:crypto");
+let _tailwindcss_node_require_cache = require("@tailwindcss/node/require-cache");
+let _weapp_tailwindcss_source_scan = require("@weapp-tailwindcss/source-scan");
 let postcss = require("postcss");
 postcss = __toESM(postcss, 1);
+let node_fs_promises = require("node:fs/promises");
+//#region src/v4/module-cache.ts
+const context = new node_async_hooks.AsyncLocalStorage();
+const caches = /* @__PURE__ */ new WeakMap();
+let revision = 0;
+const hooks = globalThis;
+let installedHook;
+let activeContexts = 0;
+const MODULE_CACHE_LIMIT = 128;
+const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+function canUseCommonJsGraph(file) {
+	const extension = node_path.default.extname(file);
+	if (extension === ".cjs" || extension === ".cts") return true;
+	if (extension !== ".js") return false;
+	const manifest = (0, node_module.findPackageJSON)((0, node_url.pathToFileURL)(file).href);
+	return !manifest || node_path.default.basename(manifest) !== "package.json" || JSON.parse((0, node_fs.readFileSync)(manifest, "utf8")).type !== "module";
+}
+function collectCommonJsDependencies(file, dependencies) {
+	const module = require$1.cache[file];
+	if (!module?.loaded) return false;
+	const visited = /* @__PURE__ */ new Set();
+	const packageRoot = node_path.default.dirname((0, node_module.findPackageJSON)((0, node_url.pathToFileURL)(file).href) ?? file);
+	function visit(current) {
+		if (visited.has(current) || !current.filename) return;
+		visited.add(current);
+		let directory = node_path.default.dirname(current.filename);
+		const relative = node_path.default.relative(packageRoot, current.filename);
+		while (node_path.default.dirname(directory) !== directory) {
+			if (node_path.default.basename(directory) === "node_modules" && (relative.startsWith(`..${node_path.default.sep}`) || node_path.default.isAbsolute(relative))) return;
+			directory = node_path.default.dirname(directory);
+		}
+		dependencies.add(current.filename);
+		for (const child of current.children) visit(child);
+	}
+	visit(module);
+	return true;
+}
+function fingerprint(files) {
+	const hash = (0, node_crypto.createHash)("sha256");
+	for (const file of files) {
+		hash.update(file);
+		hash.update((0, node_fs.readFileSync)(file));
+	}
+	return hash.digest("hex");
+}
+async function loadCachedModule(loader, file) {
+	let state = caches.get(loader);
+	if (!state || state.revision !== revision) {
+		state = {
+			revision,
+			entries: /* @__PURE__ */ new Map()
+		};
+		caches.set(loader, state);
+	}
+	const cache = state.entries;
+	const previous = cache.get(file);
+	if (previous) {
+		const entry = await previous;
+		try {
+			if (fingerprint(entry.dependencies) === entry.fingerprint) return entry;
+		} catch {}
+		if (cache.get(file) !== previous) return loadCachedModule(loader, file);
+		(0, _tailwindcss_node_require_cache.clearRequireCache)(entry.dependencies);
+	}
+	const pending = context.run(void 0, async () => {
+		const dependencies = /* @__PURE__ */ new Set([file]);
+		const base = node_path.default.dirname(file);
+		const onDependency = (dependency) => {
+			dependencies.add(dependency);
+		};
+		let loaded = previous || !canUseCommonJsGraph(file) ? void 0 : await loader.loadModule(file, base, onDependency);
+		if (!loaded || !collectCommonJsDependencies(file, dependencies)) loaded = await loader.loadModule(`./${node_path.default.basename(file)}`, base, onDependency);
+		const files = [...dependencies].sort();
+		return {
+			dependencies: files,
+			fingerprint: fingerprint(files),
+			value: { default: loaded.module }
+		};
+	});
+	cache.set(file, pending);
+	while (cache.size > MODULE_CACHE_LIMIT) cache.delete(cache.keys().next().value);
+	try {
+		return await pending;
+	} catch (error) {
+		if (cache.get(file) === pending) cache.delete(file);
+		throw error;
+	}
+}
+function installHook() {
+	if (installedHook && hooks.__tw_load === installedHook) return;
+	const previous = hooks.__tw_load;
+	installedHook = async (url) => {
+		const overridden = await previous?.(url);
+		if (overridden) return overridden;
+		const active = context.getStore();
+		if (!active?.loader.loadModule || !url.startsWith("file:")) return;
+		const parsed = new URL(url);
+		const file = (0, _weapp_tailwindcss_source_scan.resolveSourceScanPath)((0, node_url.fileURLToPath)(parsed));
+		if (!parsed.searchParams.has("id") && !active.files.has(file)) return;
+		const entry = await loadCachedModule(active.loader, file);
+		for (const dependency of entry.dependencies) active.onDependency?.(dependency);
+		return entry.value;
+	};
+	hooks.__tw_load = installedHook;
+}
+function invalidateGenerationModuleCache() {
+	revision += 1;
+}
+/** 仅在本引擎调用内复用本地模块；Tailwind 仍负责解析与依赖跟踪。 */
+async function withGenerationModuleCache(loader, run, files = [], onDependency) {
+	installHook();
+	const resolved = files.map((file) => {
+		for (const candidate of [
+			file,
+			`${file}.ts`,
+			node_path.default.join(file, "index.ts")
+		]) try {
+			return (0, _weapp_tailwindcss_source_scan.resolveSourceScanPath)(require$1.resolve(candidate));
+		} catch {}
+		return (0, _weapp_tailwindcss_source_scan.resolveSourceScanPath)(file);
+	});
+	activeContexts += 1;
+	try {
+		return await context.run({
+			loader,
+			files: new Set(resolved),
+			onDependency
+		}, run);
+	} finally {
+		activeContexts -= 1;
+		if (activeContexts === 0) context.disable();
+	}
+}
+//#endregion
+//#region src/v4/module-requests.ts
+/** 固定本地模块身份，依赖跟踪与刷新由生成模块缓存负责。 */
+function prepareGenerationModuleRequests(css, base) {
+	const files = [];
+	if (!css.includes("@config") && !css.includes("@plugin")) return {
+		css,
+		files
+	};
+	const root = postcss.default.parse(css);
+	root.walkAtRules((rule) => {
+		if (rule.name !== "config" && rule.name !== "plugin") return;
+		const match = /^(["'])(.*)\1$/.exec(rule.params.trim());
+		if (!match) return;
+		const request = match[2];
+		const pathApi = /^[a-z]:[\\/]/i.test(base) || base.includes("\\") ? node_path.default.win32 : node_path.default;
+		if (!pathApi.isAbsolute(request) && !request.startsWith(".")) return;
+		const file = pathApi.resolve(base, request);
+		files.push(file);
+		rule.params = JSON.stringify(file.replaceAll("\\", "/"));
+	});
+	return {
+		css: root.toString(),
+		files
+	};
+}
+//#endregion
 //#region src/v4/node-adapter.ts
 const nodeModulePromiseCache = /* @__PURE__ */ new Map();
 const designSystemPromiseCache = /* @__PURE__ */ new Map();
@@ -112,7 +273,8 @@ async function createTailwindV4DesignSystem(source) {
 	const node = await loadTailwindV4NodeModule([source.projectRoot, ...bases]);
 	let lastError;
 	for (const base of bases) try {
-		return await node.__unstable__loadDesignSystem(source.css, { base });
+		const prepared = prepareGenerationModuleRequests(source.css, base);
+		return await withGenerationModuleCache(node, () => node.__unstable__loadDesignSystem(prepared.css, { base }), prepared.files);
 	} catch (error) {
 		lastError = error;
 	}
@@ -139,14 +301,14 @@ async function compileTailwindV4Source(source) {
 	for (const base of bases) {
 		const dependencies = new Set(source.dependencies);
 		try {
+			const prepared = prepareGenerationModuleRequests(source.css, base);
+			const onDependency = (dependency) => dependencies.add(node_path.default.resolve(dependency));
 			return {
-				compiled: await node.compile(source.css, {
+				compiled: await withGenerationModuleCache(node, () => node.compile(prepared.css, {
 					base,
 					customCssResolver: createFallbackCssResolver([source.projectRoot, ...bases]),
-					onDependency(dependency) {
-						dependencies.add(node_path.default.resolve(dependency));
-					}
-				}),
+					onDependency
+				}), prepared.files, onDependency),
 				dependencies
 			};
 		} catch (error) {
@@ -157,6 +319,17 @@ async function compileTailwindV4Source(source) {
 	throw new Error("Failed to compile Tailwind CSS v4 source.");
 }
 //#endregion
+//#region src/v4/source-scan/matcher.ts
+function isFileMatchedByTailwindV4SourceEntries(file, entries) {
+	return (0, _weapp_tailwindcss_source_scan.isFileMatchedByTailwindSourceEntries)(file, entries, { requirePositive: true });
+}
+function createTailwindV4SourceEntryMatcher(entries) {
+	return entries?.length ? (file) => isFileMatchedByTailwindV4SourceEntries(file, entries) : void 0;
+}
+function createTailwindV4SourceExclusionMatcher(entries) {
+	return entries?.length ? (file) => (0, _weapp_tailwindcss_source_scan.isFileExcludedByTailwindSourceEntries)(file, entries) : void 0;
+}
+//#endregion
 //#region src/v4/source-scan/sources.ts
 const TAILWIND_V4_IGNORED_CONTENT_DIRS = [
 	".git",
@@ -201,48 +374,6 @@ function uniqueResolvedPaths(values) {
 	}
 	return result;
 }
-function toPosixPath(value) {
-	return value.replaceAll(node_path.default.sep, "/");
-}
-function resolveSourceScanPath(value) {
-	const resolved = node_path.default.resolve(value);
-	try {
-		return node_fs.realpathSync.native(resolved);
-	} catch {
-		return resolved;
-	}
-}
-function normalizeGlobPattern(pattern) {
-	return pattern.startsWith("./") ? pattern.slice(2) : pattern;
-}
-function hasGlobMagic(value) {
-	return /[*?[\]{}()!+@]/.test(value);
-}
-function splitStaticGlobPrefix(pattern) {
-	const segments = normalizeGlobPattern(pattern).split(/[\\/]+/);
-	const prefix = [];
-	const rest = [];
-	let reachedGlob = false;
-	for (const segment of segments) {
-		if (!reachedGlob && segment && !hasGlobMagic(segment)) {
-			prefix.push(segment);
-			continue;
-		}
-		reachedGlob = true;
-		rest.push(segment);
-	}
-	return {
-		prefix,
-		rest
-	};
-}
-async function pathExistsAsDirectory(file) {
-	try {
-		return (await (0, node_fs_promises.stat)(file)).isDirectory();
-	} catch {
-		return false;
-	}
-}
 function createTailwindV4DefaultIgnoreSources(base) {
 	return [
 		...TAILWIND_V4_IGNORED_CONTENT_DIRS.map((pattern) => ({
@@ -263,117 +394,32 @@ function createTailwindV4DefaultIgnoreSources(base) {
 	];
 }
 function createTailwindV4RootSources(root, fallbackBase) {
-	if (root === "none") return [];
-	if (root === null) return [{
+	return (0, _weapp_tailwindcss_source_scan.createSourceScanPlan)({
 		base: fallbackBase,
-		pattern: TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN,
-		negated: false
-	}];
-	return [{
-		...root,
-		negated: false
-	}];
+		mode: root === "none" ? "disabled" : root === null ? "auto" : "explicit",
+		entries: root && root !== "none" ? [{
+			...root,
+			negated: false
+		}] : []
+	});
 }
 function createTailwindV4CompiledSourceEntries(root, sources, fallbackBase) {
 	return [...createTailwindV4RootSources(root, fallbackBase), ...sources];
 }
-async function resolveTailwindV4SourceEntry(sourcePath, base, negated, defaultPattern = TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN) {
-	const absoluteSource = node_path.default.isAbsolute(sourcePath) ? node_path.default.resolve(sourcePath) : node_path.default.resolve(base, sourcePath);
-	if (await pathExistsAsDirectory(absoluteSource)) return {
-		base: absoluteSource,
-		negated,
-		pattern: normalizeGlobPattern(defaultPattern)
-	};
-	if (node_path.default.isAbsolute(sourcePath)) return {
-		base: node_path.default.dirname(absoluteSource),
-		negated,
-		pattern: normalizeGlobPattern(node_path.default.basename(absoluteSource))
-	};
-	const { prefix, rest } = splitStaticGlobPrefix(sourcePath);
-	if (prefix.length > 0 && rest.length > 0) return {
-		base: node_path.default.resolve(base, ...prefix),
-		negated,
-		pattern: normalizeGlobPattern(rest.join("/"))
-	};
-	return {
-		base,
-		negated,
-		pattern: normalizeGlobPattern(sourcePath)
-	};
+function resolveTailwindV4SourceEntry(sourcePath, base, negated, defaultPattern = TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN) {
+	return (0, _weapp_tailwindcss_source_scan.resolveTailwindSourceEntry)(sourcePath, base, negated, defaultPattern);
 }
 async function normalizeTailwindV4SourceEntries(sources, options = {}) {
 	const cwd = options.cwd ? node_path.default.resolve(options.cwd) : node_process.default.cwd();
 	return Promise.all(sources.map((source) => resolveTailwindV4SourceEntry(source.pattern, source.base ? node_path.default.resolve(source.base) : cwd, source.negated, options.defaultPattern)));
 }
-function expandBracePattern(pattern) {
-	const index = pattern.indexOf("{");
-	if (index === -1) return [pattern];
-	const rest = pattern.slice(index);
-	let depth = 0;
-	let endIndex = -1;
-	for (let i = 0; i < rest.length; i++) {
-		const char = rest[i];
-		if (char === "\\") {
-			i += 1;
-			continue;
-		}
-		if (char === "{") {
-			depth += 1;
-			continue;
-		}
-		if (char === "}") {
-			depth -= 1;
-			if (depth === 0) {
-				endIndex = i;
-				break;
-			}
-		}
-	}
-	if (endIndex === -1) return [pattern];
-	const prefix = pattern.slice(0, index);
-	const inner = rest.slice(1, endIndex);
-	const suffix = rest.slice(endIndex + 1);
-	const parts = [];
-	const stack = [];
-	let lastPos = 0;
-	for (let i = 0; i < inner.length; i++) {
-		const char = inner[i];
-		if (char === "\\") {
-			i += 1;
-			continue;
-		}
-		if (char === "{") {
-			stack.push("}");
-			continue;
-		}
-		if (char === "}" && stack[stack.length - 1] === "}") {
-			stack.pop();
-			continue;
-		}
-		if (char === "," && stack.length === 0) {
-			parts.push(inner.slice(lastPos, i));
-			lastPos = i + 1;
-		}
-	}
-	parts.push(inner.slice(lastPos));
-	return parts.flatMap((part) => expandBracePattern(`${prefix}${part}${suffix}`));
-}
-function expandTailwindV4SourceEntryBraces(sources) {
-	return sources.flatMap((source) => {
-		const base = node_path.default.resolve(source.base);
-		return expandBracePattern(source.pattern).map((pattern) => ({
-			base,
-			pattern,
-			negated: source.negated
-		}));
-	});
-}
 function normalizeTailwindV4ScannerSources(sources, cwd, ignoredSources = []) {
-	return expandTailwindV4SourceEntryBraces([...sources?.length ? sources : [{
+	const baseSources = sources?.length ? sources : [{
 		base: cwd,
 		pattern: TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN,
 		negated: false
-	}], ...ignoredSources]);
+	}];
+	return (0, _weapp_tailwindcss_source_scan.expandSourceEntryBraces)([...baseSources, ...ignoredSources]);
 }
 function resolveTailwindV4SourceBaseCandidates(projectRoot, base, baseFallbacks) {
 	return uniqueResolvedPaths([
@@ -383,79 +429,6 @@ function resolveTailwindV4SourceBaseCandidates(projectRoot, base, baseFallbacks)
 	]);
 }
 //#endregion
-//#region src/v4/source-scan/matcher.ts
-function normalizeEntryPattern(entry) {
-	return node_path.default.isAbsolute(entry.pattern) ? toPosixPath(node_path.default.relative(resolveSourceScanPath(entry.base), entry.pattern)) : normalizeGlobPattern(entry.pattern);
-}
-function isFileMatchedByTailwindV4SourceEntry(file, entry) {
-	const relative = toPosixPath(node_path.default.relative(resolveSourceScanPath(entry.base), file));
-	return Boolean(relative) && !relative.startsWith("../") && !node_path.default.isAbsolute(relative) && micromatch.default.isMatch(relative, normalizeEntryPattern(entry));
-}
-function isFileExcludedByTailwindV4SourceEntries(file, entries) {
-	if (!entries?.length) return false;
-	const resolvedFile = resolveSourceScanPath(file);
-	return entries.some((entry) => entry.negated && isFileMatchedByTailwindV4SourceEntry(resolvedFile, entry));
-}
-function isFileMatchedByTailwindV4SourceEntries(file, entries) {
-	if (!entries?.length) return true;
-	const positiveEntries = entries.filter((entry) => !entry.negated);
-	const negativeEntries = entries.filter((entry) => entry.negated);
-	if (positiveEntries.length === 0) return false;
-	const resolvedFile = resolveSourceScanPath(file);
-	if (!positiveEntries.some((entry) => isFileMatchedByTailwindV4SourceEntry(resolvedFile, entry))) return false;
-	return !negativeEntries.some((entry) => isFileMatchedByTailwindV4SourceEntry(resolvedFile, entry));
-}
-function createTailwindV4SourceEntryMatcher(entries) {
-	if (!entries?.length) return;
-	return (file) => isFileMatchedByTailwindV4SourceEntries(file, entries);
-}
-function createTailwindV4SourceExclusionMatcher(entries) {
-	if (!entries?.length) return;
-	return (file) => isFileExcludedByTailwindV4SourceEntries(file, entries);
-}
-function groupTailwindV4SourceEntriesByBase(entries) {
-	const entriesByBase = /* @__PURE__ */ new Map();
-	for (const entry of entries) {
-		const base = node_path.default.resolve(entry.base);
-		const group = entriesByBase.get(base) ?? [];
-		group.push({
-			...entry,
-			base,
-			pattern: normalizeGlobPattern(entry.pattern)
-		});
-		entriesByBase.set(base, group);
-	}
-	return entriesByBase;
-}
-async function expandTailwindV4SourceEntries(entries, resolveFiles) {
-	if (entries.length === 0) return [];
-	const files = /* @__PURE__ */ new Set();
-	await Promise.all([...groupTailwindV4SourceEntriesByBase(entries).entries()].map(async ([base, group]) => {
-		const matched = await resolveFiles({
-			cwd: base,
-			sources: group
-		});
-		for (const file of matched) files.add(node_path.default.resolve(file));
-	}));
-	return [...files].filter((file) => !isFileExcludedByTailwindV4SourceEntries(file, entries));
-}
-function mergeTailwindV4SourceEntries(...entries) {
-	const result = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const group of entries) for (const entry of group ?? []) {
-		const normalized = {
-			base: node_path.default.resolve(entry.base),
-			pattern: normalizeGlobPattern(entry.pattern),
-			negated: entry.negated
-		};
-		const key = JSON.stringify(normalized);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		result.push(normalized);
-	}
-	return result;
-}
-//#endregion
 //#region src/extraction/oxide.ts
 let oxideImportPromise;
 function createOxideRuntimeDependencyError(cause) {
@@ -543,6 +516,94 @@ function createTokenLocation(input) {
 	};
 }
 //#endregion
+//#region src/extraction/candidate-extractor/project.ts
+async function resolveScannerSources(options) {
+	const cwd = options?.cwd ? node_path.default.resolve(options.cwd) : node_process.default.cwd();
+	if (options?.sources?.length || options?.css === void 0) return {
+		cwd,
+		sources: normalizeTailwindV4ScannerSources(options?.sources, cwd, options?.ignoredSources)
+	};
+	const base = options.base ? node_path.default.resolve(options.base) : cwd;
+	const { compiled } = await compileTailwindV4Source({
+		projectRoot: cwd,
+		base,
+		baseFallbacks: options.baseFallbacks?.map((baseFallback) => node_path.default.resolve(baseFallback)) ?? [],
+		css: options.css,
+		dependencies: []
+	});
+	return {
+		cwd,
+		sources: normalizeTailwindV4ScannerSources(createTailwindV4CompiledSourceEntries(compiled.root, compiled.sources, base), cwd, options.ignoredSources)
+	};
+}
+async function resolveProjectSourceFiles(options) {
+	const { sources } = await resolveScannerSources(options);
+	const { Scanner } = await getOxideModule();
+	const files = new Scanner({ sources }).files ?? [];
+	return options?.filter ? files.filter(options.filter) : files;
+}
+async function extractProjectCandidatesWithPositions(options) {
+	const { cwd, sources } = await resolveScannerSources(options);
+	const { Scanner } = await getOxideModule();
+	const scanner = new Scanner({ sources });
+	const files = scanner.files ?? [];
+	const entries = [];
+	const skipped = [];
+	const batchSize = 32;
+	for (let start = 0; start < files.length; start += batchSize) {
+		const batch = files.slice(start, start + batchSize);
+		const contents = await Promise.allSettled(batch.map((file) => node_fs.promises.readFile(file, "utf8")));
+		for (const [index, file] of batch.entries()) {
+			const result = contents[index];
+			if (result.status === "rejected") {
+				skipped.push({
+					file,
+					reason: result.reason instanceof Error ? result.reason.message : "Unknown error"
+				});
+				continue;
+			}
+			const content = result.value;
+			const extension = toExtension(file);
+			const matches = scanner.getCandidatesWithPositions({
+				file,
+				content,
+				extension
+			});
+			if (!matches.length) continue;
+			const offsets = buildLineOffsets(content);
+			for (const match of matches) entries.push(createTokenLocation({
+				cwd,
+				file,
+				content,
+				extension,
+				candidate: match.candidate,
+				position: match.position,
+				offsets
+			}));
+		}
+	}
+	return {
+		entries,
+		filesScanned: files.length,
+		skippedFiles: skipped,
+		sources
+	};
+}
+function groupTokensByFile(report, options) {
+	const key = options?.key ?? "relative";
+	const stripAbsolute = options?.stripAbsolutePaths ?? key !== "absolute";
+	return report.entries.reduce((acc, entry) => {
+		const bucketKey = key === "absolute" ? entry.file : entry.relativeFile;
+		const bucket = acc[bucketKey] ?? (acc[bucketKey] = []);
+		const value = stripAbsolute ? {
+			...entry,
+			file: entry.relativeFile
+		} : entry;
+		bucket.push(value);
+		return acc;
+	}, {});
+}
+//#endregion
 //#region src/v4/bare-arbitrary-values/escape.ts
 function escapeCssClassName(value) {
 	let result = "";
@@ -3559,6 +3620,7 @@ function createTailwindGenerationArtifact(css, source, request, classSet, rawCan
 //#region src/v4/generation-request.ts
 function toGenerationRequest(options) {
 	return {
+		...options?.excludeFiles === void 0 ? {} : { excludeFiles: options.excludeFiles },
 		...options?.candidates === void 0 ? {} : { candidates: options.candidates },
 		...options?.sources === void 0 ? {} : { sourceEntries: options.sources.map((sourceEntry, index) => ({
 			id: `source:${index}`,
@@ -3570,6 +3632,7 @@ function toGenerationRequest(options) {
 }
 function toGenerateOptions(request) {
 	return {
+		...request.excludeFiles === void 0 ? {} : { excludeFiles: request.excludeFiles },
 		...request.candidates === void 0 ? {} : { candidates: request.candidates },
 		...request.sourceEntries === void 0 ? {} : { sources: request.sourceEntries },
 		...request.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: request.bareArbitraryValues },
@@ -3608,7 +3671,7 @@ function stripCompiledSourceEntries(source) {
 		return source;
 	}
 }
-async function collectRawCandidates(source, options, compiledRoot, compiledSources = []) {
+async function collectRawCandidates(source, options, compiledRoot, compiledSources = [], onFiles) {
 	const rawCandidates = /* @__PURE__ */ new Set();
 	const extractOptions = options?.bareArbitraryValues === void 0 ? void 0 : { bareArbitraryValues: options.bareArbitraryValues };
 	for (const candidate of options?.candidates ?? []) rawCandidates.add(candidate);
@@ -3617,7 +3680,25 @@ async function collectRawCandidates(source, options, compiledRoot, compiledSourc
 		for (const candidate of candidates) rawCandidates.add(candidate.rawCandidate);
 	}
 	const filesystemSources = resolveScanSources(options, source, compiledRoot, compiledSources);
-	if (filesystemSources.length > 0) for (const candidate of await extractRawCandidates(filesystemSources, extractOptions)) rawCandidates.add(candidate);
+	if (filesystemSources.some((entry) => !entry.negated)) {
+		const excluded = new Set((options?.excludeFiles ?? []).map(_weapp_tailwindcss_source_scan.resolveSourceScanPath));
+		const files = await resolveProjectSourceFiles({
+			sources: filesystemSources,
+			filter: (file) => !excluded.has((0, _weapp_tailwindcss_source_scan.resolveSourceScanPath)(file))
+		});
+		onFiles?.(files);
+		for (const file of files) {
+			let content;
+			try {
+				content = await (0, node_fs_promises.readFile)(file, "utf8");
+			} catch (error) {
+				const code = error?.code;
+				if (code === "ENOENT" || code === "ENOTDIR") continue;
+				throw error;
+			}
+			for (const candidate of await extractRawCandidatesWithPositions(content, node_path.default.extname(file).slice(1), extractOptions)) rawCandidates.add(candidate.rawCandidate);
+		}
+	}
 	const inlineSources = extractTailwindV4InlineSourceCandidates(source.css);
 	for (const candidate of inlineSources.included) rawCandidates.add(candidate);
 	for (const candidate of inlineSources.excluded) rawCandidates.delete(candidate);
@@ -3630,6 +3711,7 @@ var TailwindGenerationSessionImpl = class {
 	runtimes = /* @__PURE__ */ new Map();
 	designSystemPromise;
 	disposed = false;
+	moduleDependencies = /* @__PURE__ */ new Set();
 	constructor(source) {
 		this.currentSource = source;
 	}
@@ -3662,10 +3744,15 @@ var TailwindGenerationSessionImpl = class {
 	invalidate(change) {
 		if (this.disposed) return;
 		if (change.type === "source") this.currentSource = change.source;
+		(0, _tailwindcss_node_require_cache.clearRequireCache)([...this.moduleDependencies]);
+		invalidateGenerationModuleCache();
+		this.moduleDependencies.clear();
 		this.runtimes.clear();
 		this.designSystemPromise = void 0;
 	}
 	dispose() {
+		(0, _tailwindcss_node_require_cache.clearRequireCache)([...this.moduleDependencies]);
+		this.moduleDependencies.clear();
 		this.runtimes.clear();
 		this.designSystemPromise = void 0;
 		this.disposed = true;
@@ -3673,12 +3760,12 @@ var TailwindGenerationSessionImpl = class {
 	assertActive() {
 		if (this.disposed) throw new Error("Tailwind generation session has been disposed.");
 	}
-	getRuntime(compileSourceEntries) {
+	getRuntime(compileSourceEntries, designSystem) {
 		this.assertActive();
 		const cached = this.runtimes.get(compileSourceEntries);
 		if (cached) return cached;
 		const source = compileSourceEntries ? this.currentSource : stripCompiledSourceEntries(this.currentSource);
-		const promise = Promise.all([compileTailwindV4Source(source), loadTailwindV4DesignSystem(source, { cache: false })]).then(([compiledSource, designSystem]) => ({
+		const promise = Promise.all([compileTailwindV4Source(source), designSystem ?? loadTailwindV4DesignSystem(source, { cache: false })]).then(([compiledSource, designSystem]) => ({
 			compiled: compiledSource.compiled,
 			dependencies: compiledSource.dependencies,
 			designSystem,
@@ -3690,28 +3777,32 @@ var TailwindGenerationSessionImpl = class {
 		});
 		return promise;
 	}
-	async resetRuntime(compileSourceEntries) {
+	async resetRuntime(compileSourceEntries, designSystem) {
 		this.runtimes.delete(compileSourceEntries);
-		return this.getRuntime(compileSourceEntries);
+		return this.getRuntime(compileSourceEntries, designSystem);
 	}
 	async generateInternal(request) {
 		this.assertActive();
 		const options = toGenerateOptions(request);
 		const compileSourceEntries = shouldCompileSourceEntries(options);
 		let runtime = await this.getRuntime(compileSourceEntries);
-		const rawCandidates = await collectRawCandidates(this.currentSource, options, runtime.compiled.root, runtime.compiled.sources);
+		const sourceFiles = [];
+		let rawCandidates = await collectRawCandidates(this.currentSource, options, runtime.compiled.root, runtime.compiled.sources, (files) => sourceFiles.push(...files));
+		if (request.prepareCandidates) rawCandidates = new Set(request.prepareCandidates(rawCandidates));
 		const classSet = resolveValidTailwindV4Candidates(runtime.designSystem, rawCandidates, { ...options.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: options.bareArbitraryValues } });
 		const inlineSources = extractTailwindV4InlineSourceCandidates(this.currentSource.css);
 		for (const candidate of inlineSources.excluded) classSet.delete(candidate);
 		const buildCandidates = new Set(canonicalizeBareArbitraryValueCandidates(classSet, options.bareArbitraryValues));
-		if ([...runtime.builtCandidates].some((candidate) => !buildCandidates.has(candidate))) runtime = await this.resetRuntime(compileSourceEntries);
+		if ([...runtime.builtCandidates].some((candidate) => !buildCandidates.has(candidate))) runtime = await this.resetRuntime(compileSourceEntries, runtime.designSystem);
 		const css = replaceBareArbitraryValueSelectors(runtime.compiled.build([...buildCandidates]), classSet, options.bareArbitraryValues);
 		runtime.builtCandidates = new Set(buildCandidates);
+		for (const dependency of runtime.dependencies) this.moduleDependencies.add(dependency);
+		const dependencies = [.../* @__PURE__ */ new Set([...runtime.dependencies, ...sourceFiles])];
 		return {
 			css,
 			classSet,
 			rawCandidates,
-			dependencies: Array.from(runtime.dependencies),
+			dependencies,
 			sources: runtime.compiled.sources,
 			root: runtime.compiled.root
 		};
@@ -3729,6 +3820,9 @@ function createTailwindV4Engine(source) {
 	const session = createTailwindV4EngineGenerationSession(source);
 	return {
 		source,
+		dispose() {
+			session.dispose();
+		},
 		loadDesignSystem() {
 			return session.loadDesignSystem();
 		},
@@ -3885,16 +3979,21 @@ async function collectTailwindV4StyleCandidates(options) {
 async function generateTailwindV4Style(options = {}) {
 	const source = options.source ?? await resolveTailwindV4Source(createSourceOptions(options));
 	const candidates = await collectTailwindV4StyleCandidates(options);
-	const result = await createTailwindV4Engine(source).generate({
-		candidates,
-		...options.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: options.bareArbitraryValues },
-		...options.scanSources === void 0 ? {} : { scanSources: options.scanSources }
-	});
-	return {
-		...result,
-		tokens: result.rawCandidates,
-		source
-	};
+	const engine = createTailwindV4Engine(source);
+	try {
+		const result = await engine.generate({
+			candidates,
+			...options.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: options.bareArbitraryValues },
+			...options.scanSources === void 0 ? {} : { scanSources: options.scanSources }
+		});
+		return {
+			...result,
+			tokens: result.rawCandidates,
+			source
+		};
+	} finally {
+		engine.dispose?.();
+	}
 }
 //#endregion
 Object.defineProperty(exports, "TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN", {
@@ -3927,12 +4026,6 @@ Object.defineProperty(exports, "__toESM", {
 		return __toESM;
 	}
 });
-Object.defineProperty(exports, "buildLineOffsets", {
-	enumerable: true,
-	get: function() {
-		return buildLineOffsets;
-	}
-});
 Object.defineProperty(exports, "canonicalizeBareArbitraryValueCandidates", {
 	enumerable: true,
 	get: function() {
@@ -3999,30 +4092,12 @@ Object.defineProperty(exports, "createTailwindV4SourceExclusionMatcher", {
 		return createTailwindV4SourceExclusionMatcher;
 	}
 });
-Object.defineProperty(exports, "createTokenLocation", {
-	enumerable: true,
-	get: function() {
-		return createTokenLocation;
-	}
-});
 Object.defineProperty(exports, "escapeCssClassName", {
 	enumerable: true,
 	get: function() {
 		return escapeCssClassName;
 	}
 });
-Object.defineProperty(exports, "expandTailwindV4SourceEntries", {
-	enumerable: true,
-	get: function() {
-		return expandTailwindV4SourceEntries;
-	}
-});
-Object.defineProperty(exports, "expandTailwindV4SourceEntryBraces", {
-	enumerable: true,
-	get: function() {
-		return expandTailwindV4SourceEntryBraces;
-	}
-});
 Object.defineProperty(exports, "extractBareArbitraryValueSourceCandidates", {
 	enumerable: true,
 	get: function() {
@@ -4035,6 +4110,12 @@ Object.defineProperty(exports, "extractBareArbitraryValueSourceCandidatesWithPos
 		return extractBareArbitraryValueSourceCandidatesWithPositions;
 	}
 });
+Object.defineProperty(exports, "extractProjectCandidatesWithPositions", {
+	enumerable: true,
+	get: function() {
+		return extractProjectCandidatesWithPositions;
+	}
+});
 Object.defineProperty(exports, "extractRawCandidates", {
 	enumerable: true,
 	get: function() {
@@ -4071,22 +4152,16 @@ Object.defineProperty(exports, "generateTailwindV4Style", {
 		return generateTailwindV4Style;
 	}
 });
-Object.defineProperty(exports, "getOxideModule", {
-	enumerable: true,
-	get: function() {
-		return getOxideModule;
-	}
-});
 Object.defineProperty(exports, "getTailwindV4DesignSystemCacheKey", {
 	enumerable: true,
 	get: function() {
 		return getTailwindV4DesignSystemCacheKey;
 	}
 });
-Object.defineProperty(exports, "groupTailwindV4SourceEntriesByBase", {
+Object.defineProperty(exports, "groupTokensByFile", {
 	enumerable: true,
 	get: function() {
-		return groupTailwindV4SourceEntriesByBase;
+		return groupTokensByFile;
 	}
 });
 Object.defineProperty(exports, "isBareArbitraryValuesEnabled", {
@@ -4095,12 +4170,6 @@ Object.defineProperty(exports, "isBareArbitraryValuesEnabled", {
 		return isBareArbitraryValuesEnabled;
 	}
 });
-Object.defineProperty(exports, "isFileExcludedByTailwindV4SourceEntries", {
-	enumerable: true,
-	get: function() {
-		return isFileExcludedByTailwindV4SourceEntries;
-	}
-});
 Object.defineProperty(exports, "isFileMatchedByTailwindV4SourceEntries", {
 	enumerable: true,
 	get: function() {
@@ -4119,18 +4188,6 @@ Object.defineProperty(exports, "loadTailwindV4NodeModule", {
 		return loadTailwindV4NodeModule;
 	}
 });
-Object.defineProperty(exports, "mergeTailwindV4SourceEntries", {
-	enumerable: true,
-	get: function() {
-		return mergeTailwindV4SourceEntries;
-	}
-});
-Object.defineProperty(exports, "normalizeGlobPattern", {
-	enumerable: true,
-	get: function() {
-		return normalizeGlobPattern;
-	}
-});
 Object.defineProperty(exports, "normalizeTailwindV4ScannerSources", {
 	enumerable: true,
 	get: function() {
@@ -4155,10 +4212,10 @@ Object.defineProperty(exports, "resolveBareArbitraryValueCandidate", {
 		return resolveBareArbitraryValueCandidate;
 	}
 });
-Object.defineProperty(exports, "resolveSourceScanPath", {
+Object.defineProperty(exports, "resolveProjectSourceFiles", {
 	enumerable: true,
 	get: function() {
-		return resolveSourceScanPath;
+		return resolveProjectSourceFiles;
 	}
 });
 Object.defineProperty(exports, "resolveTailwindV4Source", {
@@ -4185,15 +4242,3 @@ Object.defineProperty(exports, "resolveValidTailwindV4Candidates", {
 		return resolveValidTailwindV4Candidates;
 	}
 });
-Object.defineProperty(exports, "toExtension", {
-	enumerable: true,
-	get: function() {
-		return toExtension;
-	}
-});
-Object.defineProperty(exports, "toPosixPath", {
-	enumerable: true,
-	get: function() {
-		return toPosixPath;
-	}
-});