weapp-tailwindcss 5.4.2 → 5.5.1

package/README.md

@@ -16,7 +16,7 @@ Bring Tailwind CSS to every platform. `weapp-tailwindcss` is the core compiler a
 
 | Target | Recommended entry |
 | --- | --- |
-| Web / H5 | `weapp-tailwindcss/vite`, Webpack/Rspack integration, or `@weapp-tailwindcss/cli` |
+| Web / H5 | `weapp-tailwindcss/vite/web` for plain Vite, or `weapp-tailwindcss/vite`, Webpack/Rspack integration |
 | uni-app / uni-app x | Vite or Webpack integration selected by the framework build chain |
 | Taro / Mpx / native mini programs | Vite, Webpack, Rspack, or Gulp integration |
 | React Native / Expo | `@weapp-tailwindcss/react-native` |
@@ -24,6 +24,18 @@ Bring Tailwind CSS to every platform. `weapp-tailwindcss` is the core compiler a
 
 Start with the [installation guide](https://tw.weapp.dev/docs/quick-start/install) or select a framework from the [documentation website](https://tw.weapp.dev/).
 
+Plain Vite Web projects can use the dedicated entry to pin the Web target and avoid inheriting framework detection from an enclosing monorepo:
+
+```ts
+import { WeappTailwindcssWeb } from 'weapp-tailwindcss/vite/web'
+
+export default {
+  plugins: [WeappTailwindcssWeb()],
+}
+```
+
+The repository provides three canonical templates: [uni-app](../../templates/uni-app-tailwindcss-v4), [Taro Vite](../../templates/taro-vite-tailwindcss-v4), and [weapp-vite](../../templates/weapp-vite-tailwindcss-v4). Each can be installed independently and verified with the template smoke build.
+
 ## Tailwind CSS 4 entry
 
 Your CSS entry must be imported by the application build graph. Configure `cssEntries` with absolute paths resolved from the project root when stable entry discovery is required, but do not treat it as a replacement for importing the CSS file.

package/README.zh-CN.md

@@ -16,7 +16,7 @@
 
 | 目标 | 推荐入口 |
 | --- | --- |
-| Web / H5 | `weapp-tailwindcss/vite`、Webpack/Rspack 集成或 `@weapp-tailwindcss/cli` |
+| Web / H5 | `weapp-tailwindcss/vite/web`（普通 Vite）或 `weapp-tailwindcss/vite`、Webpack/Rspack 集成 |
 | uni-app / uni-app x | 按框架构建链选择 Vite 或 Webpack 集成 |
 | Taro / Mpx / 原生小程序 | Vite、Webpack、Rspack 或 Gulp 集成 |
 | React Native / Expo | `@weapp-tailwindcss/react-native` |
@@ -24,6 +24,18 @@
 
 从[安装指南](https://tw.weapp.dev/zh-cn/docs/quick-start/install)开始，或在[中文官网](https://tw.weapp.dev/zh-cn/)按框架选择接入方式。
 
+普通 Vite Web 项目可以使用轻量入口，固定 Web target，不会因为 monorepo 上层依赖而误判为小程序框架：
+
+```ts
+import { WeappTailwindcssWeb } from 'weapp-tailwindcss/vite/web'
+
+export default {
+  plugins: [WeappTailwindcssWeb()],
+}
+```
+
+仓库提供 [uni-app](../../templates/uni-app-tailwindcss-v4)、[Taro Vite](../../templates/taro-vite-tailwindcss-v4) 和 [weapp-vite](../../templates/weapp-vite-tailwindcss-v4) 三个 canonical 模板，可直接安装并运行 smoke 构建。
+
 ## Tailwind CSS 4 入口
 
 CSS 入口必须被应用构建图实际引入。需要稳定识别入口时，通过 `cssEntries` 配置从项目根目录解析出的绝对路径，但不要把它当成 CSS import 的替代品。

package/dist/bundlers/shared/final-css-cleanup.d.ts

@@ -1,2 +1,2 @@
-export declare function hasEmptyAtRuleBlockCandidate(css: string): boolean;
+export declare function hasEmptyCssBlockCandidate(css: string): boolean;
 export declare function finalizeMiniProgramCssStructure(css: string): string;

package/dist/bundlers/shared/v4-generation-core.d.ts

@@ -2,6 +2,7 @@ import type { GenerateCssByGeneratorOptions, GenerateCssByGeneratorResult } from
 import type { CompilationDependencyChange, CompilerShadowReport, CssStage, GenerationArtifact, SourceScope } from '../../compiler/index.js';
 import type { InternalUserDefinedOptions } from '../../types/index.js';
 export interface TailwindV4GenerationCoreInput extends GenerateCssByGeneratorOptions {
+    compilerMode?: 'legacy' | undefined;
     compilationChanges?: CompilationDependencyChange[] | undefined;
     frameworkPostcssOwner?: InternalUserDefinedOptions | undefined;
     cssStage?: CssStage | undefined;

package/dist/bundlers/vite/capability-profile.d.ts

@@ -2,6 +2,7 @@ import type { ViteFrameworkName } from '../framework-selector.js';
 import type { UserDefinedOptions } from '../../types/index.js';
 export interface ViteCapabilityProfile {
     name: 'framework' | 'generic-web';
+    cssOnly?: boolean;
     frameworkName: ViteFrameworkName;
     generatorTarget: 'web' | 'weapp' | 'app' | undefined;
     platformFamily: 'web' | 'native-app' | 'mini-program' | 'unknown';

package/dist/bundlers/vite/css-finalizer/web-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import type { CssFinalizerContext } from './options.js';
+export declare function createViteWebCssFinalizerOutputPlugin(context: CssFinalizerContext): Plugin;

package/dist/bundlers/vite/css-handler-options.d.ts

@@ -0,0 +1,32 @@
+import type { InternalUserDefinedOptions, IStyleHandlerOptions } from '../../types/index.js';
+type CssHandlerOptions = IStyleHandlerOptions & {
+    postcssOptions: {
+        options: {
+            from: string;
+        };
+    };
+    majorVersion?: 4 | undefined;
+    sourceOptions?: {
+        outputRoot?: string | undefined;
+        requestFile?: string | undefined;
+    } | undefined;
+};
+interface CssHandlerOptionsCacheOptions {
+    getAppType: () => InternalUserDefinedOptions['appType'];
+    mainCssChunkMatcher: InternalUserDefinedOptions['mainCssChunkMatcher'];
+    getMajorVersion: () => number | undefined;
+    getOutputRoot?: (() => string | undefined) | undefined;
+    getExtraOptions?: ((file: string) => Partial<IStyleHandlerOptions>) | undefined;
+    getDynamicCssOptions?: (() => Partial<IStyleHandlerOptions>) | undefined;
+}
+export interface CssHandlerOptionsCache {
+    getCssHandlerOptions: (file: string) => CssHandlerOptions;
+    getCssUserHandlerOptions: (file: string) => CssHandlerOptions;
+}
+export declare function resolveViteCssHandlerExtraOptions(file: string): {
+    isMainChunk: boolean;
+} | {
+    isMainChunk?: never;
+};
+export declare function createCssHandlerOptionsCache(options: CssHandlerOptionsCacheOptions): CssHandlerOptionsCache;
+export {};

package/dist/bundlers/vite/{generate-bundle/css-output.d.ts → css-output.d.ts}

@@ -1,4 +1,4 @@
-import type { InternalUserDefinedOptions } from '../../../types/index.js';
+import type { InternalUserDefinedOptions } from '../../types/index.js';
 export declare const SOURCE_STYLE_OUTPUT_EXT_RE: RegExp;
 export declare const CSS_SOURCE_OUTPUT_EXT_RE: RegExp;
 export declare function resolveMiniProgramStyleOutputExtension(options?: {

package/dist/bundlers/vite/frameworks/generic/web.d.ts

@@ -0,0 +1,2 @@
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../../types/index.js';
+export declare function createGenericWebVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): any[] | undefined;

package/dist/bundlers/vite/generate-bundle/css-handler-options.d.ts

@@ -1,32 +1,2 @@
-import type { InternalUserDefinedOptions, IStyleHandlerOptions } from '../../../types/index.js';
-type CssHandlerOptions = IStyleHandlerOptions & {
-    postcssOptions: {
-        options: {
-            from: string;
-        };
-    };
-    majorVersion?: 4 | undefined;
-    sourceOptions?: {
-        outputRoot?: string | undefined;
-        requestFile?: string | undefined;
-    } | undefined;
-};
-interface CssHandlerOptionsCacheOptions {
-    getAppType: () => InternalUserDefinedOptions['appType'];
-    mainCssChunkMatcher: InternalUserDefinedOptions['mainCssChunkMatcher'];
-    getMajorVersion: () => number | undefined;
-    getOutputRoot?: (() => string | undefined) | undefined;
-    getExtraOptions?: ((file: string) => Partial<IStyleHandlerOptions>) | undefined;
-    getDynamicCssOptions?: (() => Partial<IStyleHandlerOptions>) | undefined;
-}
-export interface CssHandlerOptionsCache {
-    getCssHandlerOptions: (file: string) => CssHandlerOptions;
-    getCssUserHandlerOptions: (file: string) => CssHandlerOptions;
-}
-export declare function resolveViteCssHandlerExtraOptions(file: string): {
-    isMainChunk: boolean;
-} | {
-    isMainChunk?: never;
-};
-export declare function createCssHandlerOptionsCache(options: CssHandlerOptionsCacheOptions): CssHandlerOptionsCache;
-export {};
+export { createCssHandlerOptionsCache, resolveViteCssHandlerExtraOptions } from '../css-handler-options.js';
+export type { CssHandlerOptionsCache } from '../css-handler-options.js';

package/dist/bundlers/vite/generate-bundle/finalize/root-import-shell.d.ts

@@ -18,7 +18,7 @@ export interface FinalizeGenerateBundleOptions {
     formatIteration: number;
     generatorCandidateSignature: string;
     generatorRuntime: Set<string>;
-    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options.js').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
+    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('../../css-handler-options.js').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
     getSourceCandidateSourcesForEntries: GenerateBundleContext['getSourceCandidateSourcesForEntries'];
     getSourceCandidatesForEntries: GenerateBundleContext['getSourceCandidatesForEntries'];
     getViteCssCacheStats: GenerateBundleContext['getViteCssCacheStats'];

package/dist/bundlers/vite/generate-bundle/remembered-css-replay.d.ts

@@ -25,8 +25,8 @@ interface ProcessRememberedCssReplayOptions {
     emitOrReplayCssAsset: (fileName: string, source: string) => OutputAsset | undefined;
     generatorRuntime: Set<string>;
     generatorPlatform?: string | undefined;
-    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options.js').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
-    getCssUserHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('./css-handler-options.js').createCssHandlerOptionsCache>['getCssUserHandlerOptions']>;
+    getCssHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('../css-handler-options.js').createCssHandlerOptionsCache>['getCssHandlerOptions']>;
+    getCssUserHandlerOptions: (file: string) => ReturnType<ReturnType<typeof import('../css-handler-options.js').createCssHandlerOptionsCache>['getCssUserHandlerOptions']>;
     getRememberedCssSignature?: ((file: string) => string | undefined) | undefined;
     getRememberedCssSources?: (() => Iterable<[string, RememberedCssSource]>) | undefined;
     frameworkRootImportShellTargetByFile?: ReadonlyMap<string, string> | undefined;

package/dist/bundlers/vite/generate-bundle/runtime.d.ts

@@ -1,5 +1,5 @@
+import { resolveMiniProgramStyleOutputExtension as resolveMiniProgramStyleOutputExtension2, resolveReplayCssOutputFile as resolveReplayCssOutputFile2, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile as resolveViteCssPipelineOutputFile2, resolveViteCssPipelineOutputFileFromSourceFile } from '../css-output.js';
 import { normalizeBundleFileNameKeysForTest } from './bundle-file-names.js';
-import { resolveMiniProgramStyleOutputExtension as resolveMiniProgramStyleOutputExtension2, resolveReplayCssOutputFile as resolveReplayCssOutputFile2, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile as resolveViteCssPipelineOutputFile2, resolveViteCssPipelineOutputFileFromSourceFile } from './css-output.js';
 import { resolveRememberedCssSourceForTest } from './remembered-css.js';
 import { shouldKeepRootMiniProgramStyleAsImportShell as shouldKeepRootMiniProgramStyleAsImportShell2, shouldMoveRootMiniProgramStyleToImportShellOrigin as shouldMoveRootMiniProgramStyleToImportShellOrigin2 } from './root-style-output.js';
 declare function createGenerateBundleHook(context: any): any;

package/dist/bundlers/vite/generate-bundle/uni-app-x-postprocess.d.ts

@@ -1,5 +1,5 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { CssHandlerOptionsCache } from './css-handler-options.js';
+import type { CssHandlerOptionsCache } from '../css-handler-options.js';
 import type { GenerateBundleContext } from './types.js';
 interface HandleUniAppXPostCssOptions {
     bundle: Record<string, OutputAsset | OutputChunk>;

package/dist/bundlers/vite/generate-bundle.d.ts

@@ -1,7 +1,7 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
 import type { GenerateBundleContext, GenerateBundleThis } from './generate-bundle/types.js';
+export { resolveMiniProgramStyleOutputExtension, resolveReplayCssOutputFile, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile, resolveViteCssPipelineOutputFileFromSourceFile } from './css-output.js';
 export { normalizeBundleFileNameKeysForTest } from './generate-bundle/bundle-file-names.js';
-export { resolveMiniProgramStyleOutputExtension, resolveReplayCssOutputFile, resolveReplayCssOutputFileFromSourceRoot, resolveViteCssPipelineOutputFile, resolveViteCssPipelineOutputFileFromSourceFile } from './generate-bundle/css-output.js';
 export { resolveRememberedCssSourceForTest } from './generate-bundle/remembered-css.js';
 export { shouldKeepRootMiniProgramStyleAsImportShell, shouldMoveRootMiniProgramStyleToImportShellOrigin } from './generate-bundle/root-style-output.js';
 export type { GenerateBundleContext, GenerateBundleThis, RememberedCssSource } from './generate-bundle/types.js';

package/dist/bundlers/vite/runtime-class-set.d.ts

@@ -10,11 +10,7 @@ interface CreateViteRuntimeClassSetOptions {
     debug: (format: string, ...args: unknown[]) => void;
 }
 export declare function createViteRuntimeClassSet(options: CreateViteRuntimeClassSetOptions): {
-    runtimeState: {
-        tailwindRuntime: import("../../types/index.js").TailwindcssRuntimeLike;
-        readyPromise: Promise<void>;
-        refreshTailwindcssRuntime: (options?: import("../../types/index.js").RefreshTailwindcssRuntimeOptions) => Promise<import("../../types/index.js").TailwindcssRuntimeLike>;
-    };
+    runtimeState: import("../../compiler/runtime-state.js").CompilerRuntimeState;
     refreshRuntimeState: (force: boolean) => Promise<void>;
     ensureRuntimeClassSet: (force?: boolean) => Promise<Set<string>>;
     ensureBundleRuntimeClassSet: (snapshot: BundleSnapshot, forceRefresh?: boolean, options?: {

package/dist/bundlers/vite/shared/create-css-only-plugins-runtime.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import type { InternalUserDefinedOptions, UserDefinedOptions } from '../../../types/index.js';
+export declare function createCssOnlyVitePlugins(options?: UserDefinedOptions | InternalUserDefinedOptions): Plugin[] | undefined;

package/dist/cache-CBJFB1HN.cjs

@@ -0,0 +1,223 @@
+//#region src/compiler/runtime-build-state.ts
+function invertLinkedByEntry(linkedByEntry) {
+	const dependentsByLinkedFile = /* @__PURE__ */ new Map();
+	for (const [entryFile, linkedFiles] of linkedByEntry.entries()) for (const linkedFile of linkedFiles) {
+		let dependents = dependentsByLinkedFile.get(linkedFile);
+		if (!dependents) {
+			dependents = /* @__PURE__ */ new Set();
+			dependentsByLinkedFile.set(linkedFile, dependents);
+		}
+		dependents.add(entryFile);
+	}
+	return dependentsByLinkedFile;
+}
+function replaceMapEntries(target, source) {
+	target.clear();
+	for (const [key, value] of source) target.set(key, value);
+	return target;
+}
+function mergeMapEntries(target, source) {
+	for (const [key, value] of source) target.set(key, value);
+	return target;
+}
+function createRuntimeCompilationBuildState() {
+	return {
+		iteration: 0,
+		sourceHashByFile: /* @__PURE__ */ new Map(),
+		runtimeAffectingSignatureByFile: /* @__PURE__ */ new Map(),
+		runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
+		linkedByEntry: /* @__PURE__ */ new Map(),
+		dependentsByLinkedFile: /* @__PURE__ */ new Map(),
+		bundleMarkupCandidatesByFile: /* @__PURE__ */ new Map(),
+		generatorCandidateSignature: void 0
+	};
+}
+function updateRuntimeCompilationBuildState(state, snapshot, linkedByEntry, options = {}) {
+	const incremental = options.incremental === true;
+	removeRuntimeCompilationBuildStateFiles(state, snapshot.removedFiles);
+	state.iteration += 1;
+	state.sourceHashByFile = incremental ? mergeMapEntries(state.sourceHashByFile, snapshot.sourceHashByFile) : replaceMapEntries(state.sourceHashByFile, snapshot.sourceHashByFile);
+	state.runtimeAffectingSignatureByFile.clear();
+	state.runtimeAffectingHashByFile = incremental ? mergeMapEntries(state.runtimeAffectingHashByFile, snapshot.runtimeAffectingHashByFile) : replaceMapEntries(state.runtimeAffectingHashByFile, snapshot.runtimeAffectingHashByFile);
+	state.linkedByEntry = incremental ? mergeMapEntries(state.linkedByEntry, linkedByEntry) : replaceMapEntries(state.linkedByEntry, linkedByEntry);
+	state.dependentsByLinkedFile = invertLinkedByEntry(state.linkedByEntry);
+}
+function removeRuntimeCompilationBuildStateFiles(state, files) {
+	const removedFiles = new Set(files);
+	if (removedFiles.size === 0) return;
+	for (const file of removedFiles) {
+		state.sourceHashByFile.delete(file);
+		state.runtimeAffectingSignatureByFile.delete(file);
+		state.runtimeAffectingHashByFile.delete(file);
+		state.bundleMarkupCandidatesByFile.delete(file);
+		state.linkedByEntry.delete(file);
+	}
+	for (const linkedFiles of state.linkedByEntry.values()) for (const file of removedFiles) linkedFiles.delete(file);
+	state.dependentsByLinkedFile = invertLinkedByEntry(state.linkedByEntry);
+}
+function resetRuntimeCompilationBuildState(state) {
+	state.iteration = 0;
+	state.sourceHashByFile.clear();
+	state.runtimeAffectingSignatureByFile.clear();
+	state.runtimeAffectingHashByFile.clear();
+	state.linkedByEntry.clear();
+	state.dependentsByLinkedFile.clear();
+	state.bundleMarkupCandidatesByFile.clear();
+	state.generatorCandidateSignature = void 0;
+}
+function createRuntimeCompilationAffectingSignature(snapshot, computeHash) {
+	const entries = [...snapshot.runtimeAffectingHashByFile].sort(([first], [second]) => first.localeCompare(second)).map(([file, hash]) => `${file}:${hash}`);
+	return entries.length === 0 ? "runtime-affecting:0" : `runtime-affecting:1:${computeHash(entries.join("\n"))}`;
+}
+//#endregion
+//#region src/compiler/runtime-snapshot.ts
+function createChangedByType() {
+	return {
+		html: /* @__PURE__ */ new Set(),
+		js: /* @__PURE__ */ new Set(),
+		css: /* @__PURE__ */ new Set(),
+		other: /* @__PURE__ */ new Set()
+	};
+}
+function createProcessFiles() {
+	return {
+		html: /* @__PURE__ */ new Set(),
+		js: /* @__PURE__ */ new Set(),
+		css: /* @__PURE__ */ new Set()
+	};
+}
+function markProcessFile(type, file, processFiles) {
+	if (type === "html" || type === "js" || type === "css") processFiles[type].add(file);
+}
+function markFilesByEntryType(files, entriesByFile, target) {
+	for (const file of files ?? []) {
+		const entry = entriesByFile.get(file);
+		if (entry) target[entry.type].add(file);
+	}
+}
+function createRuntimeCompilationSnapshot(entries, options = {}) {
+	const changedByType = createChangedByType();
+	const runtimeAffectingChangedByType = createChangedByType();
+	const processFiles = createProcessFiles();
+	const entriesByFile = new Map(entries.map((entry) => [entry.file, entry]));
+	markFilesByEntryType(options.changedFiles, entriesByFile, changedByType);
+	markFilesByEntryType(options.runtimeAffectingChangedFiles, entriesByFile, runtimeAffectingChangedByType);
+	for (const file of options.processFiles ?? []) {
+		const entry = entriesByFile.get(file);
+		if (entry) markProcessFile(entry.type, file, processFiles);
+	}
+	return {
+		entries,
+		sourceHashByFile: /* @__PURE__ */ new Map(),
+		runtimeAffectingSignatureByFile: /* @__PURE__ */ new Map(),
+		runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
+		hasOmittedKnownFiles: options.hasOmittedKnownFiles === true,
+		removedFiles: new Set([...options.removedFiles ?? []].filter((file) => !entriesByFile.has(file))),
+		changedByType,
+		runtimeAffectingChangedByType,
+		processFiles,
+		linkedImpactsByEntry: /* @__PURE__ */ new Map()
+	};
+}
+function buildRuntimeCompilationSnapshot(entries, state, options) {
+	const snapshot = createRuntimeCompilationSnapshot(entries, {
+		hasOmittedKnownFiles: options.hasOmittedKnownFiles,
+		removedFiles: options.removedFiles
+	});
+	const firstRun = state.iteration === 0 && state.sourceHashByFile.size === 0;
+	for (const entry of entries) {
+		const { file, source, type } = entry;
+		const hash = options.computeHash(source);
+		snapshot.sourceHashByFile.set(file, hash);
+		const previousHash = state.sourceHashByFile.get(file);
+		const changed = previousHash == null || previousHash !== hash;
+		const previousRuntimeAffectingHash = state.runtimeAffectingHashByFile.get(file);
+		const runtimeAffectingHash = !changed && previousRuntimeAffectingHash != null ? previousRuntimeAffectingHash : (() => {
+			const signature = options.createRuntimeAffectingSignature(source, type);
+			snapshot.runtimeAffectingSignatureByFile.set(file, signature);
+			return options.computeHash(signature);
+		})();
+		snapshot.runtimeAffectingHashByFile.set(file, runtimeAffectingHash);
+		if (changed) snapshot.changedByType[type].add(file);
+		if (previousRuntimeAffectingHash == null || previousRuntimeAffectingHash !== runtimeAffectingHash) snapshot.runtimeAffectingChangedByType[type].add(file);
+		if (options.forceAll || firstRun) markProcessFile(type, file, snapshot.processFiles);
+		else if (type === "html") snapshot.processFiles.html.add(file);
+		else if (changed && (type === "js" || type === "css")) snapshot.processFiles[type].add(file);
+	}
+	if (!options.forceAll && !firstRun) for (const changedFile of snapshot.changedByType.js) {
+		const dependents = state.dependentsByLinkedFile.get(changedFile);
+		if (!dependents) continue;
+		for (const entryFile of dependents) {
+			snapshot.processFiles.js.add(entryFile);
+			let impacts = snapshot.linkedImpactsByEntry.get(entryFile);
+			if (!impacts) {
+				impacts = /* @__PURE__ */ new Set();
+				snapshot.linkedImpactsByEntry.set(entryFile, impacts);
+			}
+			impacts.add(changedFile);
+		}
+	}
+	return snapshot;
+}
+//#endregion
+//#region src/bundlers/shared/cache.ts
+async function processCachedTask({ cache, cacheKey, hashKey = cacheKey, rawSource, hash, readCache, applyResult, transform, onCacheHit }) {
+	let cacheHit = false;
+	const result = await cache.process({
+		key: cacheKey,
+		hashKey,
+		rawSource,
+		hash,
+		resolveCache: readCache,
+		async onCacheHit(value) {
+			cacheHit = true;
+			await applyResult(value, { cacheHit: true });
+			onCacheHit?.();
+		},
+		transform
+	});
+	if (!cacheHit) await applyResult(result, { cacheHit: false });
+}
+//#endregion
+Object.defineProperty(exports, "buildRuntimeCompilationSnapshot", {
+	enumerable: true,
+	get: function() {
+		return buildRuntimeCompilationSnapshot;
+	}
+});
+Object.defineProperty(exports, "createRuntimeCompilationAffectingSignature", {
+	enumerable: true,
+	get: function() {
+		return createRuntimeCompilationAffectingSignature;
+	}
+});
+Object.defineProperty(exports, "createRuntimeCompilationBuildState", {
+	enumerable: true,
+	get: function() {
+		return createRuntimeCompilationBuildState;
+	}
+});
+Object.defineProperty(exports, "processCachedTask", {
+	enumerable: true,
+	get: function() {
+		return processCachedTask;
+	}
+});
+Object.defineProperty(exports, "removeRuntimeCompilationBuildStateFiles", {
+	enumerable: true,
+	get: function() {
+		return removeRuntimeCompilationBuildStateFiles;
+	}
+});
+Object.defineProperty(exports, "resetRuntimeCompilationBuildState", {
+	enumerable: true,
+	get: function() {
+		return resetRuntimeCompilationBuildState;
+	}
+});
+Object.defineProperty(exports, "updateRuntimeCompilationBuildState", {
+	enumerable: true,
+	get: function() {
+		return updateRuntimeCompilationBuildState;
+	}
+});

package/dist/compiler/events.d.ts

@@ -0,0 +1,32 @@
+export type CompilationEvent = {
+    type: 'source-updated';
+    id: string;
+    source: string;
+    sourceKind?: 'css' | 'template' | 'script' | 'config' | 'asset';
+} | {
+    type: 'source-removed';
+    id: string;
+} | {
+    type: 'css-entry';
+    id: string;
+    source: string;
+} | {
+    type: 'bundle-emitted';
+    file: string;
+    artifact?: unknown;
+} | {
+    type: 'hot-update';
+    id: string;
+    mutation: 'template' | 'script' | 'style' | 'content' | 'subpackage' | 'root-style';
+} | {
+    type: 'config-changed';
+    id?: string;
+};
+export type CompilationEventListener = (event: CompilationEvent) => void | Promise<void>;
+export interface CompilationEventBus {
+    readonly revision: number;
+    emit: (event: CompilationEvent) => Promise<number>;
+    subscribe: (listener: CompilationEventListener) => () => void;
+    clear: () => void;
+}
+export declare function createCompilationEventBus(): CompilationEventBus;

package/dist/compiler/host.d.ts

@@ -0,0 +1,13 @@
+import type { GenerationArtifact } from './types.js';
+export interface CompilerHost {
+    readSource: (id: string) => string | undefined | Promise<string | undefined>;
+    resolveModule?: (specifier: string, importer: string) => string | undefined | Promise<string | undefined>;
+    getModuleInfo?: (id: string) => unknown | undefined | Promise<unknown | undefined>;
+    watchSource?: (listener: (event: CompilerHostSourceEvent) => void) => (() => void) | void;
+    emitArtifact?: (artifact: GenerationArtifact) => void | Promise<void>;
+}
+export interface CompilerHostSourceEvent {
+    id: string;
+    type: 'added' | 'changed' | 'removed';
+    source?: string | undefined;
+}

package/dist/compiler/index.d.ts

@@ -5,7 +5,9 @@ export * from './compilation-scope-graph.js';
 export * from './compilation-session-pool.js';
 export * from './composition.js';
 export * from './emission-plan.js';
+export * from './events.js';
 export * from './framework-compiler-session.js';
+export * from './host.js';
 export * from './invalidation.js';
 export * from './mode.js';
 export * from './owner-lifecycle.js';
@@ -13,6 +15,7 @@ export * from './platform-adapter.js';
 export * from './runtime-affecting-signature.js';
 export * from './runtime-build-state.js';
 export * from './runtime-snapshot.js';
+export * from './runtime-state.js';
 export * from './scope-planner.js';
 export * from './semantic-css.js';
 export * from './session.js';

package/dist/compiler/runtime-state.d.ts

@@ -0,0 +1,17 @@
+import type { CompilationEventBus } from './events.js';
+import type { RefreshTailwindcssRuntimeOptions, TailwindcssRuntimeLike } from '../types/index.js';
+export interface CompilerRuntimeState {
+    tailwindRuntime: TailwindcssRuntimeLike;
+    readyPromise: Promise<void>;
+    refreshTailwindcssRuntime: (options?: RefreshTailwindcssRuntimeOptions) => Promise<TailwindcssRuntimeLike>;
+    events: CompilationEventBus;
+    readonly revision: number;
+    dispose: () => void;
+}
+export interface CreateCompilerRuntimeStateOptions {
+    tailwindRuntime: TailwindcssRuntimeLike;
+    readyPromise?: Promise<void>;
+    refreshTailwindcssRuntime: (options?: RefreshTailwindcssRuntimeOptions) => Promise<TailwindcssRuntimeLike>;
+    events?: CompilationEventBus;
+}
+export declare function createCompilerRuntimeState(options: CreateCompilerRuntimeStateOptions): CompilerRuntimeState;