@bamboocss/vite 1.46.3 → 1.48.0

package/dist/index.mjs

@@ -43,24 +43,121 @@ 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;
+	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();
+		await builder.setup({
+			configPath,
+			cwd,
+			dev: command === "serve"
+		});
+		return publish();
+	};
+	/**
+	* 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();
+		},
+		reloadSource(filePath) {
+			openSetupStale = true;
+			builder?.reloadSource(filePath);
+		},
+		removeSource(filePath) {
+			openSetupStale = true;
+			builder?.removeSource(filePath);
+		}
 	};
-});
+};
 //#endregion
 //#region src/static-session.ts
 const createStaticCompilationSession = () => {
@@ -179,14 +276,11 @@ 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. */
@@ -221,35 +315,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?.config.polyfill) throw new Error("bamboocss: the cascade-layer polyfill is incompatible with compiled atomic styles. The polyfill removes the utility-layer boundary required for safe atom reachability and renaming.");
-		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);
@@ -257,7 +352,7 @@ const bamboocssCss = (options) => {
 			}
 		}
 		return css;
-	};
+	});
 	const generate = () => {
 		if (command === "serve" && pending && pendingGeneration === changeGeneration) return pending;
 		pendingGeneration = changeGeneration;
@@ -337,6 +432,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,
@@ -350,11 +446,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
@@ -542,6 +639,15 @@ const bamboocssCss = (options) => {
 //#endregion
 //#region src/plugin.ts
 const DEFAULT_EXTENSIONS = /\.(?:[cm]?[jt]sx?)$/;
+const SFC_EXTENSIONS = /\.(?:vue|svelte|astro)$/i;
+/**
+* Framework script submodules. Vue spells `lang.ts` as a bare query key; Svelte uses
+* `lang=ts`; both set `type=script`. The compiler must see that JS, not the wrapping SFC —
+* folding the SFC uses parser:before offsets that do not match the file Vite emits.
+*/
+const SFC_SCRIPT_QUERY = /[?&](?:type=script(?:&|$)|lang\.tsx?(?:&|$)|lang=tsx?(?:&|$)|lang\.jsx?(?:&|$))/i;
+const SFC_JSX_QUERY = /[?&](?:lang\.tsx|lang=tsx|lang\.jsx|lang=jsx)(?:&|$)/i;
+const SFC_SCRIPT_TAG = /<script[\s>/]/i;
 const NODE_MODULES = /node_modules/;
 const TRANSFORM_META_KEY = "bamboocss:transform";
 const TRANSFORM_ARTIFACT_VERSION = 3;
@@ -589,9 +695,48 @@ const shouldTransform = (id) => {
 	const [filePath] = id.split("?");
 	if (!filePath) return false;
 	if (NODE_MODULES.test(filePath)) return false;
-	return DEFAULT_EXTENSIONS.test(filePath);
+	return DEFAULT_EXTENSIONS.test(filePath) || SFC_EXTENSIONS.test(filePath);
+};
+/**
+* Path ts-morph should parse for this transform.
+*
+* A `.vue` / `.svelte` / `.astro` id is either a raw SFC (skip — offsets would not match), a
+* `type=script` submodule, or the framework's compiled JS stored under the SFC path. The last
+* two are JavaScript or TypeScript: parsing them as the SFC would run `parser:before` and fold
+* the wrong bytes. A sibling `.ts`/`.tsx` path preserves JSX parsing and skips those hooks.
+*
+* Returns `null` when the module is still a raw SFC and must be left to the framework plugin.
+* Astro frontmatter is `---`, not `<script>`, so a tag check alone would parse the template.
+*/
+const compilerParsePath = (id, code) => {
+	const [filePath, query = ""] = id.split("?");
+	if (!filePath) return null;
+	if (!SFC_EXTENSIONS.test(filePath)) return filePath;
+	const normalizedQuery = `?${query}`;
+	if (SFC_SCRIPT_QUERY.test(normalizedQuery)) return `${filePath}.__bamboo__.${SFC_JSX_QUERY.test(normalizedQuery) ? "tsx" : "ts"}`;
+	const trimmed = code.trimStart();
+	if (/\.astro$/i.test(filePath) && (trimmed.startsWith("---") || trimmed.startsWith("<"))) return null;
+	if (SFC_SCRIPT_TAG.test(code) || /<(?:template|style)[\s>/]/i.test(code)) return null;
+	if (trimmed.startsWith("<")) return null;
+	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
@@ -633,15 +778,12 @@ const formatSkipped = (id, skipped) => {
 /**
 * Vite integration for Bamboo CSS.
 *
-* Two plugins, because they do unrelated jobs on different schedules. The first emits the
-* stylesheet as a virtual module and runs in dev and build alike — that is the integration,
-* and nothing styles without it. The second compiles every Bamboo source call in both dev
-* and build; there is no runtime styling fallback.
-*
-* The compiler runs with `enforce: 'pre'` so it sees module source as close as possible to what
-* the CSS extractor reads off disk. A plugin that rewrites style calls before bamboo
-* sees them would otherwise make the two disagree, and a folded class could end up
-* with no matching rule.
+* Three plugins. The first emits the stylesheet as a virtual module. The second compiles
+* JavaScript and TypeScript with `enforce: 'pre'` so it sees source close to what the CSS
+* extractor reads off disk. The third compiles Vue, Svelte and Astro with `enforce: 'post'`
+* so it folds the framework's compiled JavaScript — a `pre` hook that skipped the raw SFC
+* would never run again on the same id. Script submodules (`type=script`) are SFC paths and
+* therefore fold in the post plugin, after the framework has extracted them.
 */
 const bamboocss = (options = {}) => {
 	const { configPath, cwd, reportSkipped = false, reportSummary = true, maxRecipeStates, pruneCss = true } = options;
@@ -649,6 +791,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,
@@ -789,6 +942,7 @@ const bamboocss = (options = {}) => {
 		dependenciesByModule: /* @__PURE__ */ new Map(),
 		filesByModule: /* @__PURE__ */ new Map(),
 		foldSignatures: /* @__PURE__ */ new Map(),
+		foldInputsByModule: /* @__PURE__ */ new Map(),
 		recipeConfigCache: /* @__PURE__ */ new Map(),
 		transformedModulesThisRun: /* @__PURE__ */ new Set(),
 		unchangedFolds: /* @__PURE__ */ new Map(),
@@ -802,6 +956,7 @@ const bamboocss = (options = {}) => {
 		dependenciesByModule: new Map([...state.dependenciesByModule].map(([moduleId, dependencies]) => [moduleId, new Set(dependencies)])),
 		filesByModule: new Map(state.filesByModule),
 		foldSignatures: new Map(state.foldSignatures),
+		foldInputsByModule: new Map(state.foldInputsByModule),
 		recipeConfigCache: new Map(state.recipeConfigCache),
 		transformedModulesThisRun: new Set(state.transformedModulesThisRun),
 		unchangedFolds: new Map(state.unchangedFolds),
@@ -1218,7 +1373,10 @@ const bamboocss = (options = {}) => {
 		state.transformArtifactsByModule.set(moduleId, artifact);
 		recordFoldDependencies(state, moduleId, file, artifact.dependencies);
 		if (artifact.signature) state.foldSignatures.set(moduleId, artifact.signature);
-		else state.foldSignatures.delete(moduleId);
+		else {
+			state.foldSignatures.delete(moduleId);
+			state.foldInputsByModule.delete(moduleId);
+		}
 	};
 	/**
 	* Replay transform metadata for modules Rollup reused from its cache.
@@ -1288,6 +1446,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);
@@ -1297,7 +1457,10 @@ const bamboocss = (options = {}) => {
 		const signature = state.foldSignatures.get(dependent);
 		if (!signature || !ctx || !foldSourceImpl || !runtimeCss || !styleCompiler) return false;
 		try {
-			const code = readFileSync(signature.path, "utf8");
+			const retained = state.foldInputsByModule.get(dependent);
+			const code = retained?.input === signature.input ? retained.code : readFileSync(signature.path, "utf8");
+			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;
 			/**
@@ -1314,7 +1477,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;
@@ -1323,24 +1486,25 @@ const bamboocss = (options = {}) => {
 			}
 			let raw;
 			let parserDependencies;
-			const memoKey = foldMemoKey(signature.path, inputDigest);
+			const memoKey = foldMemoKey(parsePath, inputDigest);
 			const memoized = foldMemoByContent.get(memoKey);
 			if (memoized) {
 				raw = memoized.result;
 				parserDependencies = memoized.parserDependencies;
 			} else {
-				const sourceFile = ctx.project.addSourceFile(signature.path, code);
-				const parserResult = ctx.project.parseSourceFile(signature.path);
+				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,
 					code,
 					parserResult,
-					filePath: signature.path,
+					filePath: parsePath,
 					runtimeCss,
 					styleCompiler,
 					maxRecipeStates,
-					parseModule: (path) => ctx?.project.parseSourceFile(path),
+					parseModule: parseForCompiler,
 					recipeConfigCache: state.recipeConfigCache,
 					reportSurvivors: false,
 					sourceFile
@@ -1353,7 +1517,7 @@ const bamboocss = (options = {}) => {
 					reportedSurvivors: false
 				});
 			}
-			const result = withResolutionClosure(signature.path, raw, parserDependencies, state.dependenciesByModule.get(dependent));
+			const result = withResolutionClosure(parsePath, raw, parserDependencies, state.dependenciesByModule.get(dependent));
 			const unchanged = digest(result.code) === signature.output;
 			/**
 			* Edges re-recorded exactly on the way to suppressing a module. A changed provisional
@@ -1480,6 +1644,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;
@@ -1519,25 +1685,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;
@@ -1654,6 +1892,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) {
@@ -1709,18 +1948,21 @@ const bamboocss = (options = {}) => {
 			if (!filePath) return;
 			for (const state of transformStateByEnvironment.values()) state.recipeConfigCache.clear();
 			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;
 					recordFoldDependencies(state, moduleId, moduleFile, []);
 					state.foldSignatures.delete(moduleId);
+					state.foldInputsByModule.delete(moduleId);
 					state.transformArtifactsByModule.delete(moduleId);
 					state.filesByModule.delete(moduleId);
 				}
 				return;
 			}
-			ctx.project.reloadSourceFile(filePath);
+			if (SFC_EXTENSIONS.test(filePath)) return;
+			host.reloadSource(filePath);
 			/**
 			* Fold the edited file before the browser asks for it.
 			*
@@ -1739,12 +1981,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,
@@ -1754,7 +1998,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
@@ -1813,136 +2057,7 @@ const bamboocss = (options = {}) => {
 			return foldDependentModules(environmentState(this), file, modules, legacy.moduleGraph);
 		},
 		async transform(code, id) {
-			if (!shouldTransform(id)) return null;
-			try {
-				await ensureCompilerState();
-			} catch (error) {
-				throw asError(error, "failed to initialize the bamboo compiler");
-			}
-			if (!ctx || !foldSourceImpl || !runtimeCss || !styleCompiler) return null;
-			const [filePath] = id.split("?");
-			if (isGeneratedOutput(filePath, ctx)) return null;
-			const state = environmentState(this);
-			state.transformedModulesThisRun.add(id);
-			let inputDigest;
-			const previousSignature = state.foldSignatures.get(id);
-			const previousDependencies = previousSignature && previousSignature.input === (inputDigest ??= digest(code)) ? state.dependenciesByModule.get(id) : void 0;
-			let result;
-			try {
-				const memoKey = command === "serve" ? foldMemoKey(filePath, inputDigest ??= digest(code)) : void 0;
-				const memoized = memoKey ? foldMemoByContent.get(memoKey) : void 0;
-				let valueReads = [];
-				if (memoized?.reportedSurvivors) {
-					valueReads = memoized.valueReads;
-					result = withResolutionClosure(filePath, memoized.result, memoized.parserDependencies, previousDependencies);
-				} else {
-					const sourceFile = ctx.project.addSourceFile(filePath, code);
-					const parserResult = ctx.project.parseSourceFile(filePath);
-					if (!parserResult) {
-						state.transformArtifactsByModule.delete(id);
-						recordFoldDependencies(state, id, filePath, []);
-						state.foldSignatures.delete(id);
-						return null;
-					}
-					const folded = foldSourceImpl({
-						ctx,
-						code,
-						parserResult,
-						filePath,
-						runtimeCss,
-						styleCompiler,
-						maxRecipeStates,
-						parseModule: (path) => ctx?.project.parseSourceFile(path),
-						recipeConfigCache: state.recipeConfigCache,
-						reportSurvivors: true,
-						sourceFile
-					});
-					const parserDependencies = parserResult.getDependencies();
-					valueReads = parserResult.getExportReads?.() ?? [];
-					if (memoKey) foldMemoByContent.set(memoKey, {
-						result: folded,
-						parserDependencies,
-						valueReads,
-						reportedSurvivors: true
-					});
-					result = withResolutionClosure(filePath, folded, parserDependencies, previousDependencies);
-				}
-				state.exportReadsByModule.set(id, [...valueReads.map((read) => ({
-					kind: "value",
-					...read
-				})), ...result.exportReads]);
-			} catch (error) {
-				logger.caughtError("vite:transform", `Failed to compile ${filePath}`, error);
-				const previousDependencies = [...state.dependenciesByModule.get(id) ?? []];
-				applyTransformArtifact(state, sealTransformArtifact(environmentName(this), {
-					version: TRANSFORM_ARTIFACT_VERSION,
-					moduleId: id,
-					file: filePath,
-					folded: 0,
-					skipped: [["compile-failed", 1]],
-					survivors: [{
-						line: 1,
-						name: "compiler",
-						reason: "compile-failed"
-					}],
-					transformedFile: false,
-					classNames: [],
-					dependencies: previousDependencies
-				}), id, environmentName(this));
-				state.foldSignatures.delete(id);
-				if (command === "serve") throw asError(error, `failed to compile ${filePath}`);
-				return null;
-			}
-			const skippedHere = /* @__PURE__ */ new Map();
-			for (const entry of result.skipped) skippedHere.set(entry.reason, (skippedHere.get(entry.reason) ?? 0) + 1);
-			const survivorsHere = [];
-			for (const entry of result.skipped) {
-				if (entry.reason === "not-imported" || entry.reason === "overlapping") continue;
-				if (entry.name === "cx" && entry.reason === "dynamic") continue;
-				survivorsHere.push({
-					line: lineAt(code, entry.start),
-					name: entry.name,
-					reason: entry.reason
-				});
-			}
-			const artifact = sealTransformArtifact(environmentName(this), {
-				version: TRANSFORM_ARTIFACT_VERSION,
-				moduleId: id,
-				file: filePath,
-				folded: result.folded.length,
-				skipped: [...skippedHere],
-				survivors: survivorsHere,
-				transformedFile: result.folded.some((entry) => entry.kind === "class" || entry.kind === "slots"),
-				classNames: [...new Set(result.folded.flatMap((entry) => entry.classNames))],
-				dependencies: [...result.dependencies],
-				...result.dependencies.length ? { signature: {
-					input: inputDigest ??= digest(code),
-					output: digest(result.code),
-					path: filePath
-				} } : {}
-			});
-			applyTransformArtifact(state, artifact, id, environmentName(this));
-			if (reportSkipped && result.skipped.length) logger.info("vite:transform", formatSkipped(filePath, result.skipped));
-			for (const dependency of result.dependencies) this.addWatchFile?.(dependency);
-			if (command === "serve" && artifact.survivors.length) {
-				state.foldSignatures.delete(id);
-				throw createSurvivorError(artifact.survivors.map((survivor) => ({
-					file: filePath,
-					...survivor
-				})));
-			}
-			const meta = { [TRANSFORM_META_KEY]: artifact };
-			if (!result.folded.length) return typeof this.getModuleInfo === "function" ? {
-				code,
-				map: null,
-				meta
-			} : null;
-			logger.debug("vite:transform", `Compiled ${result.folded.length} call(s) in ${filePath}`);
-			return {
-				code: result.code,
-				map: result.map,
-				meta
-			};
+			return compileModule.call(this, code, id, false);
 		},
 		buildEnd(buildError) {
 			const environment = environmentName(this);
@@ -1990,6 +2105,176 @@ const bamboocss = (options = {}) => {
 			if (state) rollbackEnvironmentGeneration(environment, state);
 		}
 	};
+	const compilerSfc = {
+		name: "bamboocss:compiler-sfc",
+		enforce: "post",
+		sharedDuringBuild: true,
+		async transform(code, id) {
+			return compileModule.call(this, code, id, true);
+		}
+	};
+	async function compileModule(code, id, sfcOnly) {
+		if (!shouldTransform(id)) return null;
+		const [pathForFilter] = id.split("?");
+		if (!pathForFilter) return null;
+		if (SFC_EXTENSIONS.test(pathForFilter) !== sfcOnly) return null;
+		try {
+			await ensureCompilerState();
+		} catch (error) {
+			throw asError(error, "failed to initialize the bamboo compiler");
+		}
+		if (!ctx || !foldSourceImpl || !runtimeCss || !styleCompiler) return null;
+		const [filePath] = id.split("?");
+		if (isGeneratedOutput(filePath, ctx)) return null;
+		const requestedParsePath = compilerParsePath(id, code);
+		if (requestedParsePath === null) return null;
+		const state = environmentState(this);
+		state.transformedModulesThisRun.add(id);
+		let inputDigest;
+		const previousSignature = state.foldSignatures.get(id);
+		const previousDependencies = previousSignature && previousSignature.input === (inputDigest ??= digest(code)) ? state.dependenciesByModule.get(id) : void 0;
+		let result;
+		try {
+			/**
+			* 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: path,
+					runtimeCss,
+					styleCompiler,
+					maxRecipeStates,
+					parseModule: parseForCompiler,
+					recipeConfigCache: state.recipeConfigCache,
+					reportSurvivors: true,
+					sourceFile
+				});
+				const parserDependencies = parserResult.getDependencies();
+				const valueReads = parserResult.getExportReads?.() ?? [];
+				if (memoKey) foldMemoByContent.set(memoKey, {
+					result: folded,
+					parserDependencies,
+					valueReads,
+					reportedSurvivors: true
+				});
+				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;
+			}
+			result = compiled.result;
+			state.exportReadsByModule.set(id, [...compiled.valueReads.map((read) => ({
+				kind: "value",
+				...read
+			})), ...result.exportReads]);
+		} catch (error) {
+			logger.caughtError("vite:transform", `Failed to compile ${filePath}`, error);
+			const previousDependencies = [...state.dependenciesByModule.get(id) ?? []];
+			applyTransformArtifact(state, sealTransformArtifact(environmentName(this), {
+				version: TRANSFORM_ARTIFACT_VERSION,
+				moduleId: id,
+				file: filePath,
+				folded: 0,
+				skipped: [["compile-failed", 1]],
+				survivors: [{
+					line: 1,
+					name: "compiler",
+					reason: "compile-failed"
+				}],
+				transformedFile: false,
+				classNames: [],
+				dependencies: previousDependencies
+			}), id, environmentName(this));
+			state.foldSignatures.delete(id);
+			state.foldInputsByModule.delete(id);
+			if (command === "serve") throw asError(error, `failed to compile ${filePath}`);
+			return null;
+		}
+		const skippedHere = /* @__PURE__ */ new Map();
+		for (const entry of result.skipped) skippedHere.set(entry.reason, (skippedHere.get(entry.reason) ?? 0) + 1);
+		const survivorsHere = [];
+		for (const entry of result.skipped) {
+			if (entry.reason === "not-imported" || entry.reason === "overlapping") continue;
+			if (entry.name === "cx" && entry.reason === "dynamic") continue;
+			survivorsHere.push({
+				line: lineAt(code, entry.start),
+				name: entry.name,
+				reason: entry.reason
+			});
+		}
+		const artifact = sealTransformArtifact(environmentName(this), {
+			version: TRANSFORM_ARTIFACT_VERSION,
+			moduleId: id,
+			file: filePath,
+			folded: result.folded.length,
+			skipped: [...skippedHere],
+			survivors: survivorsHere,
+			transformedFile: result.folded.some((entry) => entry.kind === "class" || entry.kind === "slots"),
+			classNames: [...new Set(result.folded.flatMap((entry) => entry.classNames))],
+			dependencies: [...result.dependencies],
+			...result.dependencies.length ? { signature: {
+				input: inputDigest ??= digest(code),
+				output: digest(result.code),
+				path: filePath
+			} } : {}
+		});
+		applyTransformArtifact(state, artifact, id, environmentName(this));
+		if (artifact.signature && (command === "serve" || requestedParsePath !== filePath)) state.foldInputsByModule.set(id, {
+			code,
+			input: artifact.signature.input,
+			parsePath: requestedParsePath
+		});
+		else state.foldInputsByModule.delete(id);
+		if (reportSkipped && result.skipped.length) logger.info("vite:transform", formatSkipped(filePath, result.skipped));
+		for (const dependency of result.dependencies) this.addWatchFile?.(dependency);
+		if (command === "serve" && artifact.survivors.length) {
+			state.foldSignatures.delete(id);
+			state.foldInputsByModule.delete(id);
+			throw createSurvivorError(artifact.survivors.map((survivor) => ({
+				file: filePath,
+				...survivor
+			})));
+		}
+		const meta = { [TRANSFORM_META_KEY]: artifact };
+		if (!result.folded.length) return typeof this.getModuleInfo === "function" ? {
+			code,
+			map: null,
+			meta
+		} : null;
+		logger.debug("vite:transform", `Compiled ${result.folded.length} call(s) in ${filePath}`);
+		return {
+			code: result.code,
+			map: result.map,
+			meta
+		};
+	}
 	const outputWriteObserver = {
 		name: "bamboocss:output-write-observer",
 		enforce: "pre",
@@ -2022,12 +2307,17 @@ const bamboocss = (options = {}) => {
 			}
 		}
 	};
-	return [bamboocssCss({
-		configPath,
-		cwd,
-		session: staticSession,
-		pruneCss
-	}), compiler];
+	return [
+		bamboocssCss({
+			configPath,
+			cwd,
+			host,
+			session: staticSession,
+			pruneCss
+		}),
+		compiler,
+		compilerSfc
+	];
 };
 //#endregion
 export { VIRTUAL_CSS_ID, bamboocss, bamboocss as default };