@bamboocss/vite 1.47.0 → 1.48.1

package/dist/index.mjs

@@ -43,24 +43,156 @@ const loadCssOutputModule = createLazyCssOutputModule();
 const createLazyFoldModule = (loadFold = () => import("./fold-module.mjs")) => createRetryableLazy(loadFold);
 /** One process-wide fold-module load shared by every plugin instance and Vite environment. */
 const loadFoldModule = createLazyFoldModule();
-/** One Builder per CSS plugin instance, created only when a hook first needs it. */
+/**
+* The one Builder a run compiles against, created only when a hook first needs it.
+*
+* Per host rather than per plugin instance: the compiler and the stylesheet share it now.
+* @see `createCompilationHost`
+*/
 const createLazyBuilder = (loadNode = loadNodeModule) => createRetryableLazy(async () => {
 	const { Builder } = await loadNode();
 	return new Builder();
 });
-/** Build and publish one complete fold state; no caller can observe partial initialization. */
-const createLazyCompilerState = (loadContext, loadFold) => createRetryableLazy(async () => {
-	const [context, fold] = await Promise.all([loadContext(), loadFold()]);
-	const runtimeCss = fold.createRuntimeCss(context);
-	const styleCompiler = fold.createStaticStyleSetCompiler(context, runtimeCss);
+//#endregion
+//#region src/compilation-host.ts
+const createCompilationHost = (options = {}) => {
+	const { configPath, cwd } = options;
+	const loadBuilder = options.loadBuilder ?? createLazyBuilder();
+	let command = "build";
+	let builder;
+	let generation;
+	let nextGenerationId = 0;
+	/**
+	* The setup covering the pass currently open.
+	*
+	* A cold start reaches this twice — the compiler's `pre` `buildStart`, then the CSS
+	* plugin's — for one instant in which nothing can have changed on disk. Sharing one attempt
+	* across both is what keeps a project from loading and evaluating its config twice per
+	* build. Cleared once a stylesheet pass consumes it, and on any source mutation, so no
+	* later pass can be answered by a setup taken before an edit.
+	*/
+	let openSetup;
+	let openSetupStale = false;
+	let cssPass;
+	let changedSourceFiles = /* @__PURE__ */ new Set();
+	let needsInventoryScan = false;
+	let needsConfigReload = false;
+	const recordSourceChange = (filePath, event, options) => {
+		changedSourceFiles.add(filePath);
+		if (event !== "update") needsInventoryScan = true;
+		needsConfigReload ||= options?.needsConfigReload === true;
+		openSetupStale = true;
+	};
+	const takeSourceChanges = () => {
+		const changes = {
+			files: [...changedSourceFiles].sort(),
+			needsInventoryScan,
+			...needsConfigReload ? { needsConfigReload: true } : {}
+		};
+		changedSourceFiles = /* @__PURE__ */ new Set();
+		needsInventoryScan = false;
+		needsConfigReload = false;
+		return changes;
+	};
+	const restoreSourceChanges = (changes) => {
+		for (const file of changes.files) changedSourceFiles.add(file);
+		needsInventoryScan ||= changes.needsInventoryScan === true;
+		needsConfigReload ||= changes.needsConfigReload === true;
+	};
+	const settled = async (attempt) => {
+		try {
+			await attempt;
+		} catch {}
+	};
+	const publish = () => {
+		const context = builder.getContextOrThrow();
+		if (generation?.context !== context) generation = {
+			id: ++nextGenerationId,
+			context,
+			encoder: context.encoder.clone()
+		};
+		return generation;
+	};
+	const runSetup = async () => {
+		builder ??= await loadBuilder();
+		const sourceChanges = takeSourceChanges();
+		try {
+			await builder.setup({
+				configPath,
+				cwd,
+				dev: command === "serve",
+				...command === "serve" ? { sourceChanges } : {}
+			});
+			return publish();
+		} catch (error) {
+			if (command === "serve") restoreSourceChanges(sourceChanges);
+			throw error;
+		}
+	};
+	/**
+	* The setup covering the pass currently open, started at most once.
+	*
+	* Started through a resolved promise, so a synchronous throw becomes the same
+	* rejected-attempt contract a failed module load has and a later hook can retry it. A
+	* source mutation observed while one is in flight does not cancel it — two overlapping
+	* `Builder.setup` calls would interleave their change detection — it queues a fresh one
+	* behind it.
+	*/
+	const setupOnce = () => {
+		const previous = openSetup;
+		if (previous && !openSetupStale) return previous;
+		openSetupStale = false;
+		const attempt = previous ? settled(previous).then(runSetup) : Promise.resolve().then(runSetup);
+		openSetup = attempt;
+		attempt.catch(() => {
+			if (openSetup === attempt) openSetup = void 0;
+		});
+		return attempt;
+	};
 	return {
-		context,
-		foldSource: fold.foldSource,
-		verifyExportReads: fold.verifyExportReads,
-		runtimeCss,
-		styleCompiler
+		setCommand(next) {
+			command = next;
+		},
+		current: () => generation,
+		async ensureGeneration() {
+			if (cssPass) await settled(cssPass);
+			if (generation) return Promise.resolve(generation);
+			return setupOnce();
+		},
+		isCssPassActive: () => cssPass !== void 0,
+		async runCssPass(run) {
+			while (cssPass) await settled(cssPass);
+			let release;
+			cssPass = new Promise((resolve) => {
+				release = resolve;
+			});
+			try {
+				const passGeneration = await setupOnce();
+				return await run(builder, passGeneration);
+			} finally {
+				openSetup = void 0;
+				openSetupStale = false;
+				cssPass = void 0;
+				release();
+			}
+		},
+		async runCompilerWork(run) {
+			while (cssPass) await settled(cssPass);
+			return run();
+		},
+		noteSourceChange(filePath, event, options) {
+			if (command === "serve") recordSourceChange(filePath, event, options);
+		},
+		reloadSource(filePath) {
+			recordSourceChange(filePath, "update");
+			builder?.reloadSource(filePath);
+		},
+		removeSource(filePath) {
+			recordSourceChange(filePath, "update");
+			builder?.removeSource(filePath);
+		}
 	};
-});
+};
 //#endregion
 //#region src/static-session.ts
 const createStaticCompilationSession = () => {
@@ -179,24 +311,26 @@ const asError = (error, context) => error instanceof Error ? error : new Error(`
 * process just wrote, which is a race on any watch rebuild.
 */
 const bamboocssCss = (options) => {
-	const { configPath, cwd, loadCssOutput = loadCssOutputModule, session, pruneCss = true } = options;
+	const { configPath, cwd, loadCssOutput = loadCssOutputModule, session, host = createCompilationHost({
+		configPath,
+		cwd
+	}), pruneCss = true } = options;
 	let builder;
-	const loadBuilder = createLazyBuilder();
-	const ensureBuilder = async () => {
-		const loaded = await loadBuilder();
-		builder = loaded;
-		return loaded;
-	};
 	let server;
 	let command = "build";
 	/** The run's own `build` options, for a bundler with no per-environment config. */
 	let ssrBuildOptions;
-	/** Included owners plus local modules their extraction actually resolved and read. */
+	/** Every source, resolver input and expanded config dependency which can change the sheet. */
 	const extractedSourceFiles = () => {
 		const activeBuilder = builder;
 		const context = activeBuilder?.context;
 		if (!context) return [];
-		return [...new Set([...context.getFiles(), ...activeBuilder.getResolutionReadFiles()].map((file) => context.runtime.path.abs(context.config.cwd, file)))];
+		return [...new Set([
+			...activeBuilder.getSourceFiles(),
+			...activeBuilder.getResolutionReadFiles(),
+			...activeBuilder.getResolutionConfigurationFiles(),
+			...context.explicitDeps
+		].map((file) => context.runtime.path.abs(context.config.cwd, file)))];
 	};
 	/**
 	* Serialised, because both `load` and the watcher can reach it and `Builder` keeps one
@@ -221,34 +355,36 @@ const bamboocssCss = (options) => {
 	let changeGeneration = 0;
 	let pendingGeneration = -1;
 	let servedCss;
-	const build = async () => {
-		const builder = await ensureBuilder();
-		await builder.setup({
-			configPath,
-			cwd,
-			dev: command === "serve"
-		});
-		await builder.emit();
-		builder.extract();
+	/**
+	* Held by the host for its whole length, rather than only around each mutation.
+	*
+	* Extraction fills the encoder this sheet is emitted from and `toCss` reads it back, with a
+	* deliberate macrotask between them. The compiler shares the AST both halves run against,
+	* so a transform folding a module in that window would re-prepare a source the extraction
+	* pass has already read and `toCss` has not finished reporting on. The host makes compiler
+	* work wait instead; a fold is a few milliseconds and this is the one place correctness
+	* depends on it.
+	*/
+	const build = () => host.runCssPass(async (activeBuilder) => {
+		builder = activeBuilder;
+		await activeBuilder.emit();
+		activeBuilder.extract();
 		await new Promise((settle) => setImmediate(settle));
-		if (builder.context) {
-			session.utilityLayer = builder.context.config.layers?.utilities ?? "utilities";
+		if (activeBuilder.context) {
+			session.utilityLayer = activeBuilder.context.config.layers?.utilities ?? "utilities";
 			session.extractedFiles.clear();
 			for (const file of extractedSourceFiles()) session.extractedFiles.add(file);
 		}
 		let graphAtomHashes;
-		if (builder.context) {
-			builder.context.encoder.atomizeObservedRecipes();
-			graphAtomHashes = new Set(builder.context.encoder.atomic);
+		if (activeBuilder.context) {
+			activeBuilder.context.encoder.atomizeObservedRecipes();
+			graphAtomHashes = new Set(activeBuilder.context.encoder.atomic);
 		}
-		const css = builder.toCss({
-			layerParams: true,
-			includeRecipes: false
-		});
+		const css = activeBuilder.toCss({ layerParams: true });
 		session.prunableClasses.clear();
 		session.viewTransitionClasses.clear();
-		if (graphAtomHashes && builder.context) {
-			const decoder = builder.context.decoder.collect(builder.context.encoder);
+		if (graphAtomHashes && activeBuilder.context) {
+			const decoder = activeBuilder.context.decoder.collect(activeBuilder.context.encoder);
 			for (const atom of decoder.atomic) if (graphAtomHashes.has(atom.hash)) session.prunableClasses.add(atom.className);
 			for (const transition of decoder.view_transitions) {
 				session.viewTransitionClasses.add(transition.className);
@@ -256,7 +392,7 @@ const bamboocssCss = (options) => {
 			}
 		}
 		return css;
-	};
+	});
 	const generate = () => {
 		if (command === "serve" && pending && pendingGeneration === changeGeneration) return pending;
 		pendingGeneration = changeGeneration;
@@ -336,6 +472,7 @@ const bamboocssCss = (options) => {
 		sharedDuringBuild: true,
 		async configResolved(config) {
 			command = config.command;
+			host.setCommand(config.command);
 			session.sourcemap = config.build.sourcemap;
 			ssrBuildOptions = {
 				ssr: config.build.ssr,
@@ -349,11 +486,12 @@ const bamboocssCss = (options) => {
 			* edited all afternoon. Nothing watched it: `watch` is the CLI's own watcher, and a
 			* project running `vite dev` never reaches it.
 			*
-			* A restart rather than re-emitting the stylesheet, because this plugin and the compiler
-			* hold *separate* contexts and only this one reloads its config. A token *value* edit
-			* came out right on the next source change, and an edit that changes what compiles —
-			* adding a token, a condition, a utility — left the compiler naming classes from the old
-			* config against a sheet emitted from the new one. Half-updated is worse than stale.
+			* A restart rather than re-emitting the stylesheet. The two plugins share one context now,
+			* and the compiler re-derives everything it holds when `Builder.setup` replaces it — so the
+			* half-updated state this used to prevent, with the compiler naming classes from the old
+			* config against a sheet emitted from the new one, can no longer happen. What a restart
+			* still buys is the rest of the server: a changed `outdir`, a preset that adds an entry
+			* point, and every module Vite has already transformed against the previous config.
 			*
 			* Through Vite's own list rather than a watcher of ours. Vite adds these paths to the
 			* files it watches, which is what reaches a config *outside* `root` — a monorepo with one
@@ -446,23 +584,27 @@ const bamboocssCss = (options) => {
 			* about. Vite 5 has one graph and no `environments`, where the question is exact.
 			*/
 			const clientGraph = devServer.environments?.client?.moduleGraph ?? devServer.moduleGraph;
-			const invalidate = (file) => {
-				const ctx = builder?.context;
+			const invalidate = (file, event) => {
+				const activeBuilder = builder;
+				const ctx = activeBuilder?.context;
 				if (!ctx) return;
 				const absoluteFile = ctx.runtime.path.abs(ctx.config.cwd, file);
-				if (!session.extractedFiles.has(absoluteFile)) return;
+				const wasExtracted = session.extractedFiles.has(absoluteFile);
+				const changesConfigMembership = event !== "update" && activeBuilder.isPotentialConfigDependency(absoluteFile);
+				if (!wasExtracted && (event !== "create" || !activeBuilder.isPotentialSourceFile(absoluteFile) && !changesConfigMembership)) return;
+				host.noteSourceChange(absoluteFile, event, { needsConfigReload: changesConfigMembership });
 				changeGeneration++;
 				prebuilt = void 0;
 				const mod = server?.moduleGraph.getModuleById(RESOLVED_ID);
 				if (!mod) return;
-				if (clientGraph.getModulesByFile(absoluteFile)?.size) return;
+				if (wasExtracted && clientGraph.getModulesByFile(absoluteFile)?.size) return;
 				server?.moduleGraph.invalidateModule(mod);
 				server?.reloadModule(mod);
 				logger.debug("vite", `styles invalidated by ${absoluteFile}`);
 			};
-			devServer.watcher.on("change", invalidate);
-			devServer.watcher.on("add", invalidate);
-			devServer.watcher.on("unlink", invalidate);
+			devServer.watcher.on("change", (file) => invalidate(file, "update"));
+			devServer.watcher.on("add", (file) => invalidate(file, "create"));
+			devServer.watcher.on("unlink", (file) => invalidate(file, "delete"));
 		},
 		generateBundle: {
 			order: "post",
@@ -623,6 +765,22 @@ const compilerParsePath = (id, code) => {
 	return `${filePath}.__bamboo__.ts`;
 };
 /**
+* Where to park a transform's text when it is not what the shared Project holds for the file.
+*
+* The compiler folds the bundler's view of a module — after every `enforce: 'pre'` plugin
+* before it, and after Vite's own load. The stylesheet pass reads the same file off disk
+* through the same ts-morph Project. When the two texts differ and the compiler writes its
+* own under the file's path, that transform silently becomes the canonical source for the
+* next extraction pass: the CSS would then be generated from a bundler artifact rather than
+* from the checkout. Under a sibling path both readings exist and neither overwrites the
+* other, which is the same reason `compilerParsePath` already does this for SFC submodules.
+*
+* The extension carries JSX-ness across, since it is what ts-morph keys its script kind on:
+* anything but an unambiguously non-JSX `.ts`/`.mts`/`.cts` is parsed as `.tsx`, so a `<div>`
+* in a `.js` file still parses and a `<T>value` assertion in a `.ts` file still means a cast.
+*/
+const auxiliaryParsePath = (filePath) => `${filePath}.__bamboo__.${/\.[cm]?ts$/i.test(filePath) ? "ts" : "tsx"}`;
+/**
 * Is this file part of the generated `styled-system` rather than the user's source?
 *
 * Resolved to a path and compared as a prefix, rather than by looking for the outdir's
@@ -677,6 +835,17 @@ const bamboocss = (options = {}) => {
 	if (maxRecipeStates !== void 0 && (!Number.isSafeInteger(maxRecipeStates) || maxRecipeStates < 1)) throw new Error("bamboocss: `maxRecipeStates` must be a positive safe integer.");
 	if ("renameCssAsset" in options) throw new Error("bamboocss: `renameCssAsset` has been replaced by `pruneCss`. Use `pruneCss: false` for what `renameCssAsset: false` did — it always disabled the pruning as well, since pruned bytes under the unpruned sheet's name is what lets a CDN serve a stale stylesheet. The new name says which of the two it is really about.");
 	const staticSession = createStaticCompilationSession();
+	/**
+	* One Builder, one resolved config, one context and one ts-morph project for the run.
+	*
+	* Created here rather than by either plugin because both need it and neither may own it:
+	* the compiler used to load a second config of its own, which is why a token edit could
+	* leave it naming classes from the old one against a sheet emitted from the new one.
+	*/
+	const host = createCompilationHost({
+		configPath,
+		cwd
+	});
 	const transformArtifactIntegrityKey = randomBytes(32);
 	const serializeTransformArtifact = (environment, artifact) => JSON.stringify([
 		TRANSFORM_META_KEY,
@@ -1321,6 +1490,8 @@ const bamboocss = (options = {}) => {
 	const foldOutputUnchanged = (state, dependent, changedFile) => {
 		const memoized = state.unchangedFolds.get(dependent);
 		if (memoized !== void 0) return memoized;
+		if (host.isCssPassActive()) return false;
+		if (!compilerStateIsCurrent()) return false;
 		const unchanged = state.changedRun < CHANGED_RUN_LIMIT && refoldMatchesSignature(state, dependent, changedFile);
 		state.changedRun = unchanged ? 0 : state.changedRun + 1;
 		state.unchangedFolds.set(dependent, unchanged);
@@ -1332,7 +1503,8 @@ const bamboocss = (options = {}) => {
 		try {
 			const retained = state.foldInputsByModule.get(dependent);
 			const code = retained?.input === signature.input ? retained.code : readFileSync(signature.path, "utf8");
-			const parsePath = retained?.input === signature.input ? retained.parsePath : signature.path;
+			const requestedParsePath = retained?.input === signature.input ? retained.parsePath : signature.path;
+			const parsePath = compilerSourcePath(signature.path, requestedParsePath, code);
 			const inputDigest = digest(code);
 			if (inputDigest !== signature.input) return false;
 			/**
@@ -1349,7 +1521,7 @@ const bamboocss = (options = {}) => {
 			*/
 			const reads = state.exportReadsByModule.get(dependent);
 			if (reads?.length && verifyExportReadsImpl) {
-				const { verdict, crossings } = verifyExportReadsImpl(ctx, (path) => ctx?.project.parseSourceFile(path), reads, normalizeFsPath(changedFile), verifyDigestMemo);
+				const { verdict, crossings } = verifyExportReadsImpl(ctx, parseForCompiler, reads, normalizeFsPath(changedFile), verifyDigestMemo);
 				if (verdict === "unchanged") {
 					recordFoldDependencies(state, dependent, signature.path, [...state.dependenciesByModule.get(dependent) ?? [], ...crossings]);
 					return true;
@@ -1364,8 +1536,9 @@ const bamboocss = (options = {}) => {
 				raw = memoized.result;
 				parserDependencies = memoized.parserDependencies;
 			} else {
-				const sourceFile = ctx.project.addSourceFile(parsePath, code);
-				const parserResult = ctx.project.parseSourceFile(parsePath);
+				const sourceFile = addCompilerSource(signature.path, parsePath, code);
+				if (!sourceFile) return false;
+				const parserResult = parseForCompiler(parsePath, requestedParsePath === signature.path ? signature.path : parsePath);
 				if (!parserResult) return false;
 				raw = foldSourceImpl({
 					ctx,
@@ -1375,7 +1548,7 @@ const bamboocss = (options = {}) => {
 					runtimeCss,
 					styleCompiler,
 					maxRecipeStates,
-					parseModule: (path) => ctx?.project.parseSourceFile(path),
+					parseModule: parseForCompiler,
 					recipeConfigCache: state.recipeConfigCache,
 					reportSurvivors: false,
 					sourceFile
@@ -1515,6 +1688,8 @@ const bamboocss = (options = {}) => {
 		return [...modules, ...added];
 	};
 	let ctx;
+	/** The compiler's private parse sink for `ctx`. @see `CompilationGeneration.encoder` */
+	let parseEncoder;
 	let foldSourceImpl;
 	let verifyExportReadsImpl;
 	let runtimeCss;
@@ -1554,25 +1729,97 @@ const bamboocss = (options = {}) => {
 			dependencies: expanded
 		};
 	};
-	const loadContext = createRetryableLazy(async () => {
-		const { loadConfigAndCreateContext } = await loadNodeModule();
-		return loadConfigAndCreateContext({
-			configPath,
-			cwd,
-			dev: command === "serve"
-		});
-	});
-	const loadCompilerState = createLazyCompilerState(loadContext, loadFoldModule);
+	/** Which context the published derivations below were built from. */
+	let derivedGeneration = -1;
+	/** Compiler-only sibling ASTs retained for each physical module. */
+	const auxiliarySourcesByFile = /* @__PURE__ */ new Map();
+	/**
+	* Whether the compiler state below still describes the context the host is on.
+	*
+	* Only `ensureCompilerState` re-derives, and only an awaited hook may call it — so the two
+	* synchronous entry points, the speculative prefold and the unchanged-dependent check, can
+	* be reached after a stylesheet pass has published a config reload they have not seen. Both
+	* decline rather than fold against a runtime `css` from the previous config.
+	*/
+	const compilerStateIsCurrent = () => {
+		const current = host.current();
+		return current !== void 0 && current.id === derivedGeneration;
+	};
 	const ensureContext = async () => {
-		ctx = await loadContext();
+		ctx = (await host.ensureGeneration()).context;
 	};
+	/**
+	* Load the fold chunk and derive everything that depends on the resolved context.
+	*
+	* Keyed on context *identity* rather than derived once. `Builder.setup` replaces its context
+	* on a config reload, and the runtime `css`, the style-set compiler and the parse sink are
+	* all closures over the previous one — a stale `runtimeCss` names classes from the old
+	* config while the stylesheet is emitted from the new one, and nothing downstream can see
+	* the difference. Re-derivation is cheap; both factories are a handful of bound methods.
+	*
+	* Published as a set, and only once every part of the attempt has succeeded, so a failed
+	* chunk load leaves no half-compiler visible to HMR.
+	*/
 	const ensureCompilerState = async () => {
-		const loaded = await loadCompilerState();
-		ctx = loaded.context;
-		foldSourceImpl = loaded.foldSource;
-		verifyExportReadsImpl = loaded.verifyExportReads;
-		runtimeCss = loaded.runtimeCss;
-		styleCompiler = loaded.styleCompiler;
+		const [initialGeneration, fold] = await Promise.all([host.ensureGeneration(), loadFoldModule()]);
+		const currentGeneration = await host.ensureGeneration();
+		const generation = currentGeneration.id === initialGeneration.id ? initialGeneration : currentGeneration;
+		if (derivedGeneration === generation.id && foldSourceImpl) {
+			ctx = generation.context;
+			return;
+		}
+		const derivedRuntimeCss = fold.createRuntimeCss(generation.context);
+		const derivedStyleCompiler = fold.createStaticStyleSetCompiler(generation.context, derivedRuntimeCss);
+		ctx = generation.context;
+		parseEncoder = generation.encoder;
+		foldSourceImpl = fold.foldSource;
+		verifyExportReadsImpl = fold.verifyExportReads;
+		runtimeCss = derivedRuntimeCss;
+		styleCompiler = derivedStyleCompiler;
+		derivedGeneration = generation.id;
+		auxiliarySourcesByFile.clear();
+	};
+	/**
+	* Parse a module for the compiler, never for the stylesheet.
+	*
+	* Every compiler parse goes through here so the private encoder cannot be forgotten at one
+	* call site. Forgetting it at any of them puts that module's reading into the encoder the
+	* sheet is emitted from, under a `parse` owner nothing retracts.
+	*/
+	const parseForCompiler = (filePath, hookFilePath = filePath) => ctx?.project.parseSourceFile(filePath, parseEncoder, { hookFilePath });
+	/**
+	* Where the compiler may hold `code` for `filePath` without displacing the checkout.
+	*
+	* The file's own path exactly when the shared Project already holds these bytes — then
+	* `addSourceFile` is a lookup and there is nothing to displace. @see `auxiliaryParsePath`
+	*/
+	const compilerSourcePath = (filePath, requested, code) => {
+		if (requested !== filePath) return requested;
+		return ctx?.project.getSourceFile(filePath)?.getFullText() === code ? filePath : auxiliaryParsePath(filePath);
+	};
+	/** Add one compiler-owned source without letting it displace or outlive its physical file. */
+	const addCompilerSource = (filePath, parsePath, code) => {
+		if (!ctx) return;
+		const auxiliary = parsePath !== filePath;
+		const sourceFile = ctx.project.addSourceFile(parsePath, code, { auxiliary });
+		if (auxiliary) {
+			const physical = normalizeFsPath(filePath);
+			const paths = auxiliarySourcesByFile.get(physical) ?? /* @__PURE__ */ new Set();
+			paths.add(parsePath);
+			auxiliarySourcesByFile.set(physical, paths);
+		}
+		return sourceFile;
+	};
+	/** Release compiler encoder owners and sibling ASTs when their physical module disappears. */
+	const releaseCompilerSources = (filePath) => {
+		if (!ctx) return;
+		parseEncoder?.releaseFile(filePath);
+		const physical = normalizeFsPath(filePath);
+		for (const auxiliary of auxiliarySourcesByFile.get(physical) ?? []) {
+			parseEncoder?.releaseFile(auxiliary);
+			ctx.project.removeSourceFile(auxiliary);
+		}
+		auxiliarySourcesByFile.delete(physical);
 	};
 	const outputFinalizerTag = (value) => {
 		if (!value || typeof value !== "object") return void 0;
@@ -1689,6 +1936,7 @@ const bamboocss = (options = {}) => {
 		},
 		configResolved(config) {
 			command = config.command;
+			host.setCommand(config.command);
 			defaultEmitAssets = config.build?.emitAssets ?? (!config.build?.ssr || config.build?.ssrEmitAssets === true);
 			const plugins = config.plugins;
 			if (plugins) {
@@ -1738,14 +1986,15 @@ const bamboocss = (options = {}) => {
 				state.unchangedFolds.clear();
 				state.changedRun = 0;
 			}
-			if (!ctx) return;
-			if (!shouldTransform(id)) return;
 			const [filePath] = id.split("?");
 			if (!filePath) return;
+			if (change.event === "update") host.noteSourceChange(filePath, change.event);
+			if (!ctx) return;
+			if (!shouldTransform(id)) return;
 			for (const state of transformStateByEnvironment.values()) state.recipeConfigCache.clear();
-			if (SFC_EXTENSIONS.test(filePath)) return;
 			if (change.event === "delete") {
-				ctx.project.removeSourceFile(filePath);
+				host.removeSource(filePath);
+				releaseCompilerSources(filePath);
 				const deleted = normalizeFsPath(filePath);
 				for (const state of transformStateByEnvironment.values()) for (const [moduleId, moduleFile] of [...state.filesByModule]) {
 					if (normalizeFsPath(moduleFile) !== deleted) continue;
@@ -1757,7 +2006,8 @@ const bamboocss = (options = {}) => {
 				}
 				return;
 			}
-			ctx.project.reloadSourceFile(filePath);
+			if (SFC_EXTENSIONS.test(filePath)) return;
+			host.reloadSource(filePath);
 			/**
 			* Fold the edited file before the browser asks for it.
 			*
@@ -1776,12 +2026,14 @@ const bamboocss = (options = {}) => {
 			*/
 			if (command === "serve") setImmediate(() => {
 				if (!ctx || !foldSourceImpl || !runtimeCss || !styleCompiler) return;
+				if (host.isCssPassActive() || !compilerStateIsCurrent()) return;
 				try {
 					const code = readFileSync(filePath, "utf8");
 					const memoKey = foldMemoKey(filePath, digest(code));
 					if (foldMemoByContent.has(memoKey)) return;
-					const sourceFile = ctx.project.addSourceFile(filePath, code);
-					const parserResult = ctx.project.parseSourceFile(filePath);
+					const sourceFile = addCompilerSource(filePath, filePath, code);
+					if (!sourceFile) return;
+					const parserResult = parseForCompiler(filePath);
 					if (!parserResult) return;
 					const folded = foldSourceImpl({
 						ctx,
@@ -1791,7 +2043,7 @@ const bamboocss = (options = {}) => {
 						runtimeCss,
 						styleCompiler,
 						maxRecipeStates,
-						parseModule: (path) => ctx?.project.parseSourceFile(path),
+						parseModule: parseForCompiler,
 						recipeConfigCache: transformStateByEnvironment.get("client")?.recipeConfigCache ?? /* @__PURE__ */ new Map(),
 						reportSurvivors: true,
 						sourceFile
@@ -1919,8 +2171,8 @@ const bamboocss = (options = {}) => {
 		if (!ctx || !foldSourceImpl || !runtimeCss || !styleCompiler) return null;
 		const [filePath] = id.split("?");
 		if (isGeneratedOutput(filePath, ctx)) return null;
-		const parsePath = compilerParsePath(id, code);
-		if (parsePath === null) return null;
+		const requestedParsePath = compilerParsePath(id, code);
+		if (requestedParsePath === null) return null;
 		const state = environmentState(this);
 		state.transformedModulesThisRun.add(id);
 		let inputDigest;
@@ -1928,46 +2180,62 @@ const bamboocss = (options = {}) => {
 		const previousDependencies = previousSignature && previousSignature.input === (inputDigest ??= digest(code)) ? state.dependenciesByModule.get(id) : void 0;
 		let result;
 		try {
-			const memoKey = command === "serve" ? foldMemoKey(parsePath, inputDigest ??= digest(code)) : void 0;
-			const memoized = memoKey ? foldMemoByContent.get(memoKey) : void 0;
-			let valueReads = [];
-			if (memoized?.reportedSurvivors) {
-				valueReads = memoized.valueReads;
-				result = withResolutionClosure(parsePath, memoized.result, memoized.parserDependencies, previousDependencies);
-			} else {
-				const sourceFile = ctx.project.addSourceFile(parsePath, code);
-				const parserResult = ctx.project.parseSourceFile(parsePath);
-				if (!parserResult) {
-					state.transformArtifactsByModule.delete(id);
-					recordFoldDependencies(state, id, filePath, []);
-					state.foldSignatures.delete(id);
-					state.foldInputsByModule.delete(id);
-					return null;
-				}
+			/**
+			* One serialized region, holding every read and every mutation of the shared AST.
+			*
+			* Synchronous throughout, which is what makes waiting for the stylesheet pass once at
+			* the top sufficient: nothing can open a pass between the wait and the work, because
+			* nothing else runs. The fold is CPU-bound anyway, so there is no await to give up.
+			*/
+			const compiled = await host.runCompilerWork(() => {
+				if (!ctx || !foldSourceImpl || !runtimeCss || !styleCompiler) return null;
+				const path = compilerSourcePath(filePath, requestedParsePath, code);
+				const memoKey = command === "serve" ? foldMemoKey(path, inputDigest ??= digest(code)) : void 0;
+				const memoized = memoKey ? foldMemoByContent.get(memoKey) : void 0;
+				if (memoized?.reportedSurvivors) return {
+					valueReads: memoized.valueReads,
+					result: withResolutionClosure(path, memoized.result, memoized.parserDependencies, previousDependencies)
+				};
+				const sourceFile = addCompilerSource(filePath, path, code);
+				if (!sourceFile) return null;
+				const parserResult = parseForCompiler(path, requestedParsePath === filePath ? filePath : path);
+				if (!parserResult) return { unparsed: true };
 				const folded = foldSourceImpl({
 					ctx,
 					code,
 					parserResult,
-					filePath: parsePath,
+					filePath: path,
 					runtimeCss,
 					styleCompiler,
 					maxRecipeStates,
-					parseModule: (path) => ctx?.project.parseSourceFile(path),
+					parseModule: parseForCompiler,
 					recipeConfigCache: state.recipeConfigCache,
 					reportSurvivors: true,
 					sourceFile
 				});
 				const parserDependencies = parserResult.getDependencies();
-				valueReads = parserResult.getExportReads?.() ?? [];
+				const valueReads = parserResult.getExportReads?.() ?? [];
 				if (memoKey) foldMemoByContent.set(memoKey, {
 					result: folded,
 					parserDependencies,
 					valueReads,
 					reportedSurvivors: true
 				});
-				result = withResolutionClosure(parsePath, folded, parserDependencies, previousDependencies);
+				return {
+					valueReads,
+					result: withResolutionClosure(path, folded, parserDependencies, previousDependencies)
+				};
+			});
+			if (!compiled) return null;
+			if ("unparsed" in compiled) {
+				state.transformArtifactsByModule.delete(id);
+				recordFoldDependencies(state, id, filePath, []);
+				state.foldSignatures.delete(id);
+				state.foldInputsByModule.delete(id);
+				return null;
 			}
-			state.exportReadsByModule.set(id, [...valueReads.map((read) => ({
+			result = compiled.result;
+			state.exportReadsByModule.set(id, [...compiled.valueReads.map((read) => ({
 				kind: "value",
 				...read
 			})), ...result.exportReads]);
@@ -2023,10 +2291,10 @@ const bamboocss = (options = {}) => {
 			} } : {}
 		});
 		applyTransformArtifact(state, artifact, id, environmentName(this));
-		if (artifact.signature && (command === "serve" || parsePath !== filePath)) state.foldInputsByModule.set(id, {
+		if (artifact.signature && (command === "serve" || requestedParsePath !== filePath)) state.foldInputsByModule.set(id, {
 			code,
 			input: artifact.signature.input,
-			parsePath
+			parsePath: requestedParsePath
 		});
 		else state.foldInputsByModule.delete(id);
 		if (reportSkipped && result.skipped.length) logger.info("vite:transform", formatSkipped(filePath, result.skipped));
@@ -2088,6 +2356,7 @@ const bamboocss = (options = {}) => {
 		bamboocssCss({
 			configPath,
 			cwd,
+			host,
 			session: staticSession,
 			pruneCss
 		}),